1755 行
49 KiB
MQL5
1755 行
49 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>
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
namespace TSN
|
|
{
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
struct CJsonNode;
|
|
//#define JSONPARSERBYLEO_DESACTIVE_SWAR
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
class CJsonParser : public CBaseStructuredLan
|
|
{
|
|
private:
|
|
//---
|
|
int m_stak_num[512];
|
|
int m_stak_pos[512];
|
|
char m_stak_state[512];
|
|
int m_stak_size;
|
|
int m_stak_curr;
|
|
int m_stak_curr_state;
|
|
|
|
//---
|
|
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);
|
|
__forceinline void CorrectPadding() { CorrectPadingInternal(' ');}
|
|
|
|
//---
|
|
bool Parse();
|
|
bool ParseAssembly();
|
|
int ToJsonAsm(uchar& text[]) const;
|
|
|
|
//---
|
|
__forceinline ENUM_TSN_JSON_LAST_ERR LastErr() const { return m_last_err; }
|
|
|
|
//---
|
|
string Unescape(const int start, const int end) const;
|
|
int Unescape(const int start, const int end, uchar& res[]) const;
|
|
|
|
//---
|
|
__forceinline int GetStep(const int idx) const;
|
|
__forceinline int GetStepPure(const int idx) const;
|
|
|
|
|
|
//---
|
|
void PrintCintaTypes(const int start, const int num) const;
|
|
|
|
//--- Comparacion de strings
|
|
bool StrEquals(const string &str, const int curr) const;
|
|
bool StrEquals(const int other, 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;
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
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.75, 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
|
|
}
|
|
|
|
m_tables[table_pos].bucket_size = m_pfh.m_buckets_size;
|
|
const int fn = m_pfh.m_final_table_size;
|
|
m_tables[table_pos].final_table_size = fn;
|
|
|
|
|
|
// 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::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;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CJsonParser::StrEquals(const int other, 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 s = int(m_cinta[other] >> TSN_SBL_BIT_STR_START);
|
|
const int l = int((m_cinta[other] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
|
|
|
|
//---
|
|
if(l != len)
|
|
return false;
|
|
for(int i = 0; i < l; i++)
|
|
{
|
|
if(m_raw[s + i] != m_raw[start + i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
string CJsonParser::CleanNode(int i, const int end) const
|
|
{
|
|
//---
|
|
string str;
|
|
int k = 0;
|
|
StringSetLength(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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
//--- 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++;\
|
|
}
|
|
|
|
|
|
|
|
|
|
//--- Generico
|
|
// 1 en la tabl to token es INVALID (dara error..de malformed..)
|
|
#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_last_err=TSN_JSON_ERR_MALFOMED_LEN_SUPERADO; \
|
|
return false; \
|
|
} \
|
|
continue; \
|
|
} \
|
|
const uchar _locked = m_next; \
|
|
m_next = g_table_json_tokens[_c];\
|
|
if(((1 << m_next) & g_json_expected[m_stak_curr_state][_locked]) == 0)\
|
|
{ \
|
|
m_last_err= TSN_JSON_ERR_MALFORDMED_JSON; \
|
|
return false; \
|
|
}\
|
|
break; \
|
|
}
|
|
|
|
//---
|
|
#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++;\
|
|
}
|
|
|
|
|
|
//--- 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; \
|
|
return false; \
|
|
}\
|
|
break; \
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CJsonParser::Parse()
|
|
{
|
|
//---
|
|
m_stak_size = 0;
|
|
//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:
|
|
{
|
|
//---
|
|
long v = 0;
|
|
|
|
//--- Validamos signo
|
|
long mask = 0;
|
|
uchar ch = m_raw[m_pos];
|
|
if(ch == '-')
|
|
{
|
|
mask = -1;
|
|
m_pos++; // Ahora en numero
|
|
ch = m_raw[m_pos];
|
|
}
|
|
|
|
//---
|
|
ch ^= '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;
|
|
int fract_digits = 0;
|
|
|
|
//---
|
|
while(true)
|
|
{
|
|
const uchar c = m_raw[m_pos] ^ '0';
|
|
if(c > 9)
|
|
break;
|
|
frac_int = (frac_int << 3) + (frac_int << 1) + c;
|
|
fract_digits++;
|
|
m_pos++;
|
|
}
|
|
|
|
//---
|
|
val += frac_int * g_Exp10[fract_digits];
|
|
}
|
|
|
|
//--- 10e50.02500140
|
|
if((m_raw[m_pos] | 0x20) == 'e') // e or E
|
|
{
|
|
//---
|
|
m_pos++;
|
|
bool exp_sign = true;
|
|
uchar _c = m_raw[m_pos];
|
|
if(_c == '-')
|
|
{
|
|
exp_sign = false;
|
|
m_pos++;
|
|
}
|
|
else
|
|
if(_c == '+')
|
|
{
|
|
m_pos++;
|
|
}
|
|
|
|
//---
|
|
_c = m_raw[m_pos] ^ '0';
|
|
int exp_val = 0;
|
|
|
|
//---
|
|
while(true)
|
|
{
|
|
exp_val = (exp_val << 3) + (exp_val << 1) + _c;
|
|
|
|
//---
|
|
m_pos++;
|
|
_c = m_raw[m_pos] ^ '0';
|
|
if(_c > 9)
|
|
break;
|
|
}
|
|
|
|
//---
|
|
val *= (exp_sign) ? g_Pow10[exp_val] : g_Exp10[exp_val];
|
|
}
|
|
|
|
//---
|
|
static BitInterpreter bit;
|
|
bit.double_value = val;
|
|
bit.long_value ^= (mask & (1LL << 63));
|
|
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++] = (v ^ mask) - mask;
|
|
break; // Fin
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//--- no hago el m_pos++ dado que ahora mismo estamo en el seg char
|
|
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;
|
|
if((m_pos + 7) >= m_len) // Ultimas 8 posicinoes son " " asi que seria invalido ya..
|
|
{
|
|
m_last_err = TSN_JSON_ERR_STRING_NOT_CLOSED;
|
|
return false;
|
|
}
|
|
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_SWAR_64_DEJAR_SOLO_MINUS_SIG_BYTE(has_qt);
|
|
|
|
//---
|
|
m_pos += TSNTABLES_SWAR_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);
|
|
// Aislamos los bits donde empeizan las rachas de \
|
|
const uchar starts = compacted_bs & ~(compacted_bs << 1);
|
|
// sumas especiifca para impar
|
|
const ushort sum_impar_wide = (ushort)compacted_bs + ushort(starts & TSNTABLES_MASK_IMPARES);
|
|
// Obtenemos finales de ambos...
|
|
const uchar end_par = (compacted_bs + (starts & TSNTABLES_MASK_PARES)) & ~compacted_bs;
|
|
const uchar end_impar = uchar(sum_impar_wide & 0xFF) & ~compacted_bs;
|
|
// Ahora ya sabemos donde esta los finaes impares..
|
|
const uchar end_final = (end_impar & TSNTABLES_MASK_PARES) | (end_par & TSNTABLES_MASK_IMPARES);
|
|
const uchar compacted_qt = TSNTABLES_COMPACT_UL(has_qt);
|
|
const uchar qt_final = compacted_qt & ~end_final;
|
|
//Print("nada");
|
|
|
|
//---
|
|
if(qt_final != 0) // Hay un qt real de cierre
|
|
{
|
|
// Avanzamos y cerramos..
|
|
m_pos += g_table_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((sum_impar_wide & 0x100) != 0) // Overflow el ultimo char es \ y el siguiente escapa
|
|
{
|
|
//Print("siuu");
|
|
m_pos++; // Uno mas.. luego del currend
|
|
}
|
|
|
|
// No hay ... o es escapado en caso exista
|
|
if((m_pos + 7) >= m_len) // Ultimas 8 posicinoes son " " asi que seria invalido ya..
|
|
{
|
|
m_last_err = TSN_JSON_ERR_STRING_NOT_CLOSED;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#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_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_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_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_NEXT_NO_NEXT_KEY
|
|
break;
|
|
}
|
|
case TSN_JSON_TOK_COMMA:
|
|
{
|
|
//---
|
|
m_stak_num[m_stak_curr]++;
|
|
|
|
//---
|
|
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_size++;
|
|
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_size++;
|
|
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_NO_NEXT_KEY
|
|
|
|
//---
|
|
break;
|
|
}
|
|
case TSN_JSON_TOK_LLAVE_END:
|
|
case TSN_JSON_TOK_COR_END:
|
|
{
|
|
//---
|
|
if(m_cinta_pos > m_stak_pos[m_stak_curr] + 2) // [a][a][v][c]
|
|
{
|
|
m_stak_num[m_stak_curr]++;
|
|
}
|
|
|
|
|
|
//---
|
|
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;
|
|
|
|
//---
|
|
m_stak_size = m_stak_curr--;
|
|
|
|
//---
|
|
if(m_stak_size == 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
m_stak_curr_state = m_stak_state[m_stak_curr];
|
|
|
|
//---
|
|
m_pos++;
|
|
|
|
//---
|
|
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;
|
|
if((m_pos + 7) >= m_len) // Ultimas 8 posicinoes son " " asi que seria invalido ya..
|
|
{
|
|
m_last_err = TSN_JSON_ERR_KEY_NOT_CLOSED;
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
#else // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
|
|
if(has_qt == 0) // Caso comun. .. ninguno de los dos.. continuamos..
|
|
{
|
|
m_pos += 8;
|
|
if((m_pos + 7) >= m_len) // Ultimas 8 posicinoes son " " asi que seria invalido ya..
|
|
{
|
|
m_last_err = TSN_JSON_ERR_KEY_NOT_CLOSED;
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
|
|
//---
|
|
#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_SWAR_64_DEJAR_SOLO_MINUS_SIG_BYTE(has_qt);
|
|
|
|
//---
|
|
m_pos += TSNTABLES_SWAR_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
|
|
}
|
|
|
|
//--- Hay bs si o si pero tambien puede haber "
|
|
const uchar compacted_bs = TSNTABLES_COMPACT_UL(has_bs);
|
|
// Aislamos los bits donde empeizan las rachas de \
|
|
const uchar starts = compacted_bs & ~(compacted_bs << 1);
|
|
// sumas especiifca para impar
|
|
const ushort sum_impar_wide = (ushort)compacted_bs + ushort(starts & TSNTABLES_MASK_IMPARES);
|
|
// Obtenemos finales de ambos...
|
|
const uchar end_par = (compacted_bs + (starts & TSNTABLES_MASK_PARES)) & ~compacted_bs;
|
|
const uchar end_impar = uchar(sum_impar_wide & 0xFF) & ~compacted_bs;
|
|
// Ahora ya sabemos donde esta los finaes impares..
|
|
const uchar end_final = (end_impar & TSNTABLES_MASK_PARES) | (end_par & TSNTABLES_MASK_IMPARES);
|
|
const uchar compacted_qt = TSNTABLES_COMPACT_UL(has_qt);
|
|
const uchar qt_final = compacted_qt & ~end_final;
|
|
//Print("nada");
|
|
|
|
//---
|
|
if(qt_final != 0) // Hay un qt real de cierre
|
|
{
|
|
// Avanzamos y cerramos..
|
|
m_pos += g_table_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((sum_impar_wide & 0x100) != 0) // Overflow el ultimo char es \ y el siguiente escapa
|
|
{
|
|
//Print("siuu");
|
|
m_pos++; // Uno mas.. luego del currend
|
|
}
|
|
|
|
// No hay ... o es escapado en caso exista
|
|
if((m_pos + 7) >= m_len) // Ultimas 8 posicinoes son " " asi que seria invalido ya..
|
|
{
|
|
m_last_err = TSN_JSON_ERR_KEY_NOT_CLOSED;
|
|
return false;
|
|
}
|
|
}
|
|
#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
|
|
|
|
|
|
//---
|
|
m_pos++;
|
|
if(m_pos >= m_len)
|
|
{
|
|
m_last_err = TSN_JSON_ERR_KEY_NOT_CLOSED;
|
|
return false;
|
|
}
|
|
}
|
|
#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;
|
|
}
|
|
}
|
|
//---
|
|
m_pos++; // Luego del
|
|
|
|
|
|
//--- Buscamos valor
|
|
TSN_JSON_NEXT_VALUE_COMM_KEY
|
|
|
|
//---
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
m_last_err = TSN_JSON_ERR_INVALID_CHAR;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//---
|
|
m_last_err = TSN_JSON_ERR_JSON_NOT_FINISH;
|
|
|
|
//---
|
|
return false;
|
|
}
|
|
// "llabe":"llabe";
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
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_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_HEX:
|
|
{
|
|
if(i + 2 <= end)
|
|
{
|
|
i++;
|
|
uchar v = g_arr_valid_hex_chars[m_raw[i++]];
|
|
v = (v << 4) | g_arr_valid_hex_chars[m_raw[i]];
|
|
//Print("Valor:" , v);
|
|
res[pos++] = v;
|
|
}
|
|
else
|
|
res[pos++] = 'x';
|
|
break;
|
|
}
|
|
case TSN_TABLE_UNESCAPE_INVALID:
|
|
{
|
|
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 = "";
|
|
StringSetLength(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_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_HEX:
|
|
{
|
|
if(i + 2 <= end)
|
|
{
|
|
i++;
|
|
uchar v = g_arr_valid_hex_chars[m_raw[i++]];
|
|
v = (v << 4) | g_arr_valid_hex_chars[m_raw[i]];
|
|
//Print("Valor:" , v);
|
|
res.SetChar(pos++, v);
|
|
}
|
|
else
|
|
res.SetChar(pos++, 'x');
|
|
break;
|
|
}
|
|
case TSN_TABLE_UNESCAPE_INVALID:
|
|
{
|
|
res.SetChar(pos++, c);
|
|
break;
|
|
}
|
|
default:
|
|
res.SetChar(pos++, next);
|
|
break;
|
|
}
|
|
|
|
//---
|
|
continue;
|
|
}
|
|
|
|
//---
|
|
res.SetChar(pos++, m_raw[i]);
|
|
}
|
|
|
|
//---
|
|
res.Truncate(pos);
|
|
|
|
//---
|
|
return res;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__forceinline int CJsonParser::GetStepPure(const int idx) const
|
|
{
|
|
const int tipo = int(m_cinta[idx] & 0xF);
|
|
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] & 0xF))
|
|
{
|
|
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 EMPTY_JSON_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[512]; // contenedor
|
|
int current_ends[512];
|
|
int sp = 0;
|
|
|
|
//---
|
|
manager = CDomNodeManager();
|
|
root = new CDomNodeBase(manager);
|
|
|
|
//--- 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
|
|
if(cur >= current_ends[sp])
|
|
{
|
|
sp--; // Nivel menos
|
|
if(sp <= 0)
|
|
return;
|
|
}
|
|
|
|
//---
|
|
const ENUM_JSON_VTYPE tipo = ENUM_JSON_VTYPE(m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE);
|
|
|
|
//---
|
|
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);
|
|
const string str = Unescape(s, s + slen - 1);
|
|
prev_value = root[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);
|
|
if(current_container[sp].m_type == JSON_VTYPE_ARR) // [{}]
|
|
{
|
|
const int lock = sp++;
|
|
current_container[sp] = new CDomNodeBase(current_container[sp].m_ctx);
|
|
current_container[sp].NewObj(count);
|
|
current_container[lock].AddItem(current_container[sp]);
|
|
}
|
|
else // {key:{}}
|
|
{
|
|
sp++;
|
|
prev_value = new CDomNodeBase(current_container[sp].m_ctx);
|
|
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(current_container[sp].m_ctx);
|
|
current_container[sp].NewArr(count);
|
|
current_container[lock].AddItem(current_container[sp]);
|
|
}
|
|
else // {key:[]}
|
|
{
|
|
sp++;
|
|
prev_value = new CDomNodeBase(current_container[sp].m_ctx);
|
|
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(current_container[sp].m_ctx, JSON_VTYPE_INTEGER, m_cinta[cur + 1]));
|
|
else
|
|
prev_value = m_cinta[cur + 1];
|
|
break;
|
|
}
|
|
case JSON_VTYPE_REAL:
|
|
{
|
|
static BitInterpreter un;
|
|
un.long_value = m_cinta[cur + 1];
|
|
|
|
//---
|
|
if(current_container[sp].m_type == JSON_VTYPE_ARR)
|
|
current_container[sp].AddItem(new CDomNodeBase(current_container[sp].m_ctx, JSON_VTYPE_REAL, 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(current_container[sp].m_ctx, JSON_VTYPE_BOOLEAN, 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(current_container[sp].m_ctx, JSON_VTYPE_STRING, 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(current_container[sp].m_ctx));
|
|
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);
|
|
text += "start=" + (string)s + " len=" + (string)slen + " key=\"" + CharArrayToString(m_raw, s, slen) + "\"";
|
|
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:
|
|
{
|
|
static BitInterpreter 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_CHAR_COMMA_IN_CTX_NO_OBJ_ARR:
|
|
desc = "Coma invalida fuera de un objeto o arreglo";
|
|
break;
|
|
case TSN_JSON_ERR_MALFORDMED_JSON:
|
|
desc = "JSON malformado";
|
|
break;
|
|
case TSN_JSON_ERR_INVALID_CHAR:
|
|
desc = "Caracter invalido";
|
|
break;
|
|
case TSN_JSON_ERR_MALFORMED_TRUE:
|
|
desc = "Literal 'true' malformado";
|
|
break;
|
|
case TSN_JSON_ERR_MALFORMED_FALSE:
|
|
desc = "Literal 'false' malformado";
|
|
break;
|
|
case TSN_JSON_ERR_MALFORMED_NULL:
|
|
desc = "Literal 'null' malformado";
|
|
break;
|
|
case TSN_JSON_ERR_STRING_NOT_CLOSED:
|
|
desc = "Cadena sin cerrar";
|
|
break;
|
|
case TSN_JSON_ERR_INVALID_STATE:
|
|
desc = "Estado invalido del parser";
|
|
break;
|
|
case TSN_JSON_ERR_JSON_NOT_FINISH:
|
|
desc = "El JSON no termino correctamente";
|
|
break;
|
|
case TSN_JSON_ERR_EXPECTED_OBJ_ARR:
|
|
desc = "Se esperaba un objeto o un arreglo";
|
|
break;
|
|
case TSN_JSON_ERR_OVERFLOW_IN_CINTA_RESIZE:
|
|
desc = "Overflow al redimensionar la cinta interna";
|
|
break;
|
|
case TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS:
|
|
desc = "Se esperaban dos puntos ':' despues de la clave";
|
|
break;
|
|
case TSN_JSON_ERR_MALFOMED_LEN_SUPERADO:
|
|
desc = "Longitud maxima superada";
|
|
break;
|
|
case TSN_JSON_ERR_KEY_NOT_CLOSED:
|
|
desc = "Clave sin cerrar";
|
|
break;
|
|
case TSN_JSON_ERR_HAS_NOT_CONTENT:
|
|
desc = "El JSON no tiene contenido";
|
|
break;
|
|
case TSN_JSON_ERR_INVALID_EXT_FILE:
|
|
desc = "Extension de archivo invalida";
|
|
break;
|
|
default:
|
|
desc = "Error desconocido";
|
|
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
|
|
*/
|
|
//+------------------------------------------------------------------+
|