| //+------------------------------------------------------------------+
|
| //| Parser.cpp |
|
| //| Copyright 2026, Niquel Mendoza. |
|
| //| https://www.mql5.com/ |
|
| //+------------------------------------------------------------------+
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #include "Parser.h"
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| // array ya allocado tambein raw solo hace falta rellenar
|
| using namespace TSN;
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| // Solo lo resizea.. y maneja el tema de reserva.. nada mas.. (en m_index)
|
| // m_raw ya se maneja por mql
|
| // len tambien
|
| // m_last err tamiben se inicia
|
| // m_cintapos tambien se incia por qml
|
| // pos no asi que lo hacemos aqui
|
| // offsert se nos pasa
|
| // cinta tambien se nos pasa pero lo contrala mql
|
| // index se nos pasa nosotrs oslo modifcamos
|
| extern "C" __declspec(dllexport)
|
| bool __stdcall JsonParserResolve(const uint8_t* m_raw, const int len, int* m_last_err, int* m_cinta_pos,
|
| int* m_pos, const int m_offset, int64_t* m_cinta, int* m_index)
|
| {
|
| //--- Stacks
|
| uint32_t m_stak_num[JSONPARSERBYLEO_MAX_STACK];
|
| int32_t m_stak_pos[JSONPARSERBYLEO_MAX_STACK];
|
| uint16_t m_stak_state[JSONPARSERBYLEO_MAX_STACK];
|
| int32_t m_stak_curr = -1;
|
| uint16_t m_stak_curr_state = 0;
|
| uint8_t m_next = TSN_JSON_TOK_INVALID;
|
|
|
| //--- Inicio de miembros
|
| (*m_pos) = m_offset;
|
|
|
| //--- Temp
|
| ulong prev_in_string = 0ULL;
|
| ulong prev_scape = 0ULL;
|
| int index_s = 0;
|
|
|
| //--- Intrisicos masks
|
| const __m256i mask_20 = _mm256_set1_epi8(0x20);
|
| const __m256i bs_mask = _mm256_set1_epi8('\\');
|
| const __m256i qt_mask = _mm256_set1_epi8('"');
|
| const __m128i all_ones = _mm_set1_epi8(0xFF);
|
| const __m256i op_table = _mm256_broadcastsi128_si256(_mm_setr_epi8(
|
| 0, 0, 0, 0,
|
| 0, 0, 0, 0,
|
| 0, 0, ':', '{',
|
| ',', '}', 0, 0
|
| ));
|
|
|
| //--- Fase inicial
|
| do
|
| {
|
| // carga inicial
|
| __m256i chunk_lo = _mm256_loadu_si256((const __m256i*)(m_raw + (*m_pos))); // bytes 0-31
|
| __m256i chunk_hi = _mm256_loadu_si256((const __m256i*)(m_raw + (*m_pos) + 32)); // bytes 32-63
|
|
|
| //--- Detectamos bs
|
| const uint32_t bs_bits_lo = (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk_lo, bs_mask));
|
| const uint32_t bs_bits_hi = (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk_hi, bs_mask));
|
|
|
| //--- Detectamos qt
|
| const uint32_t qt_bits_lo = (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk_lo, qt_mask));
|
| const uint32_t qt_bits_hi = (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk_hi, qt_mask));
|
|
|
| //---
|
| // compactamos ambos
|
| const ulong compacted_bs = ((ulong)bs_bits_hi << 32) | bs_bits_lo;
|
| const ulong compacted_qt = ((ulong)qt_bits_hi << 32) | qt_bits_lo;
|
|
|
| //---
|
| const ulong compacted_bs_masked = compacted_bs & ~prev_scape;
|
| const ulong prev = (((compacted_bs_masked << 1) | TSNTABLES_MASK_IMPARES_F) - compacted_bs_masked) ^ TSNTABLES_MASK_IMPARES_F;
|
| const ulong escaped = prev ^ (compacted_bs | prev_scape);
|
| prev_scape = (prev & compacted_bs_masked) >> 63;
|
|
|
| //---
|
| ulong qt_final = compacted_qt & ~escaped;
|
| const ulong quoted_pos = qt_final;
|
|
|
| //--- prefix xor
|
| __m128i clmul = _mm_clmulepi64_si128(_mm_set_epi64x(0, qt_final), all_ones, 0);
|
| qt_final = (uint64_t)_mm_cvtsi128_si64(clmul);
|
|
|
| const ulong in_string = qt_final ^ prev_in_string;
|
|
|
| //--- Ahora obtenemos los strucutrurales
|
| // ahora lo qeu haremos sera un or entre la masra de 0x20
|
| // La idea econ esto es que (en las siugientes) lineas hay un problema
|
| // noramlte con shuffle si tenemos lo sigueinte {}
|
| // se genera
|
| // {} (tal cual bien)
|
| // pero si tenemos
|
| // [] se genra {} (esto es por que se genera eso en base a los bajos)
|
| // entonces esto luego con el cmp que se hace estair ocmprand [ con { lo qeu daria 0 asi qeu se perderia
|
| // los caracteres estrucutalres, por eso le debemos de aumenar 0x20, esto hace que [ pase a {
|
| // con eso soluicionas dicho problema..
|
| __m256i curl_lo = _mm256_or_si256(chunk_lo, mask_20);
|
| __m256i curl_hi = _mm256_or_si256(chunk_hi, mask_20);
|
| // ahora usarmeos shuffle para hacer lo sigeuinte
|
| // : = 1010
|
| // ] y } = 1011
|
| // , = 1100
|
| // Como para generar strucuturales rapdios, la idea es quedarse solo con los estrucuturales
|
| // Aparte metemos un eq para confirmar.. pro qeu ahroa mismo la mascara previa
|
| // peude dar falsso posiivots (dado qeu eso de 1010... puede repetirse)
|
| __m256i op_lo = _mm256_cmpeq_epi8(_mm256_shuffle_epi8(op_table, chunk_lo), curl_lo);
|
| __m256i op_hi = _mm256_cmpeq_epi8(_mm256_shuffle_epi8(op_table, chunk_hi), curl_hi);
|
| // ahora lo basmoas a 1\0 no bytes.. para trabajar..
|
| uint32_t bits_lo = (uint32_t)_mm256_movemask_epi8(op_lo);
|
| uint32_t bits_hi = (uint32_t)_mm256_movemask_epi8(op_hi);
|
| uint64_t result = ((uint64_t)bits_hi << 32) | bits_lo;
|
|
|
| //--- overflow
|
| prev_in_string = uint64_t(static_cast<int64_t>(in_string) >> 63);
|
| ulong structural = (result & ~in_string) | quoted_pos;
|
|
|
| //--- Numero de unos aqui..
|
| const int cnt = _mm_popcnt_u64(structural);
|
| int written = 0;
|
|
|
| //---
|
| while(written + 4 <= cnt)
|
| {
|
| m_index[index_s++] = (*m_pos) + _tzcnt_u64(structural);
|
| structural &= structural - 1;
|
| m_index[index_s++] = (*m_pos) + _tzcnt_u64(structural);
|
| structural &= structural - 1;
|
| m_index[index_s++] = (*m_pos) + _tzcnt_u64(structural);
|
| structural &= structural - 1;
|
| m_index[index_s++] = (*m_pos) + _tzcnt_u64(structural);
|
| structural &= structural - 1;
|
| written += 4;
|
| }
|
| // Resto (0-3 elementos sobrantes), bucle normal
|
| while(written < cnt)
|
| {
|
| m_index[index_s++] = (*m_pos) + _tzcnt_u64(structural);
|
| structural &= structural - 1;
|
| written++;
|
| }
|
| (*m_pos) += 64; // avanzamos 64 caracteres..
|
|
|
| // Seguimos con check
|
| }
|
| while(((*m_pos) + 64) < len);
|
|
|
|
|
| //---
|
| if(index_s < 2)
|
| {
|
| // errro
|
| *m_last_err = TSN_JSON_ERR_NOT_STRUCUTURAL_CHARS_FOUND;
|
| return false;
|
| }
|
|
|
| //--- Fase 2
|
| int sp = 0;
|
| (*m_pos) = m_index[sp]; // Posicion
|
| m_next = g_table_json_tokens[m_raw[(*m_pos)]]; // primer
|
|
|
|
|
| //--- Iteracion
|
| while(true)
|
| {
|
| switch(m_next)
|
| {
|
| case TSN_JSON_TOK_NUMBER_NEG:
|
| {
|
| (*m_pos)++;
|
| JSONPARSERBYLEO_PARSE_NUMBER(-1)
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
| break;
|
| }
|
|
|
| case TSN_JSON_TOK_NUMBER:
|
| {
|
| //---
|
| JSONPARSERBYLEO_PARSE_NUMBER(0)
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
| break;
|
| }
|
|
|
| //---
|
| case TSN_JSON_TOK_STRING:
|
| {
|
| //---
|
| //TSN_JSON_RESERVAR(2)
|
|
|
| //---
|
| const int start = m_index[sp++] + 1; // luego del "
|
| (*m_pos) = m_index[sp++]; // justo en "
|
|
|
| //---
|
| m_cinta[(*m_cinta_pos)++] = JSON_VTYPE_STRING
|
| | int64_t((*m_pos) - start) << TSN_SBL_BIT_STR_LEN
|
| | int64_t(start) << TSN_SBL_BIT_STR_START;
|
|
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
|
|
| //---
|
| 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;
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
| 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;
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
| 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;
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
| break;
|
| }
|
| case TSN_JSON_TOK_COMMA:
|
| {
|
| //---
|
| m_stak_num[m_stak_curr]++;
|
|
|
| //---
|
| (*m_pos)++;
|
|
|
| //---
|
| if(m_stak_curr_state == TSN_JSON_CTX_IN_OBJ)
|
| {
|
| //---
|
| const int start = m_index[sp++] + 1; // luego del "
|
| (*m_pos) = m_index[sp++]; // justo en "
|
| //Print("start: " , start, " len: " , ((*m_pos) - start));
|
|
|
| //---
|
| m_cinta[(*m_cinta_pos)++] = (int64_t)JSON_VTYPE_KEY
|
| | int64_t((*m_pos) - start) << TSN_SBL_BIT_STR_LEN
|
| | int64_t(start) << TSN_SBL_BIT_STR_START;
|
|
|
| // Print(EnumToString(ENUM_JSON_VTYPE(m_cinta[(*m_cinta_pos) - 1] & 0xf)));
|
|
|
| //---
|
| (*m_pos) = m_index[sp++];
|
| if(m_raw[(*m_pos)++] != ':')
|
| {
|
| *m_last_err = TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS;
|
| return false;
|
| }
|
| // Ahora si buscamos valor
|
| }
|
|
|
| TSN_JSON_NEXT_VALUE_COMM_KEY
|
| break;
|
| }
|
| case TSN_JSON_TOK_LLAVE_INI:
|
| {
|
| //---
|
| sp++;
|
| //TSN_JSON_RESERVAR(1)
|
| m_cinta[(*m_cinta_pos)] = JSON_VTYPE_OBJ;
|
|
|
| //---
|
| m_stak_curr++;
|
| if(m_stak_curr >= JSONPARSERBYLEO_MAX_STACK)
|
| {
|
| *m_last_err = TSN_JSON_ERR_OVERFLOW_IN_STACK;
|
| return false; // overflow
|
| }
|
|
|
| //---
|
| 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)++;
|
|
|
| //---
|
| (*m_pos) = m_index[sp++];
|
| if(m_raw[(*m_pos)] == '}')
|
| {
|
| m_next = TSN_JSON_TOK_LLAVE_END;
|
| }
|
| else
|
| {
|
| const int start = ++(*m_pos);
|
| (*m_pos) = m_index[sp++]; // justo en "
|
|
|
| //--- Capturamos
|
| m_cinta[(*m_cinta_pos)++] = JSON_VTYPE_KEY
|
| | int64_t((*m_pos) - start) << TSN_SBL_BIT_STR_LEN
|
| | int64_t(start) << TSN_SBL_BIT_STR_START;
|
|
|
| //---
|
| (*m_pos) = m_index[sp++];
|
| if(m_raw[(*m_pos)++] != ':')
|
| {
|
| *m_last_err = TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS;
|
| return false;
|
| }
|
|
|
| // Ahora a buscar valor
|
| TSN_JSON_NEXT_VALUE_COMM_KEY
|
| }
|
|
|
| //---
|
| break;
|
| }
|
| case TSN_JSON_TOK_COR_INI:
|
| {
|
| //---
|
| sp++;
|
| //TSN_JSON_RESERVAR(1)
|
| m_cinta[(*m_cinta_pos)] = JSON_VTYPE_ARR;
|
|
|
| //---
|
| m_stak_curr++;
|
| if(m_stak_curr >= JSONPARSERBYLEO_MAX_STACK)
|
| {
|
| *m_last_err = TSN_JSON_ERR_OVERFLOW_IN_STACK;
|
| return false; // overflow
|
| }
|
|
|
| //---
|
| 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)++;
|
| //Print(CharToString(m_raw[(*m_pos)]));
|
|
|
| //---
|
| const int n = m_index[sp];
|
| if(m_raw[n] != ']')
|
| {
|
| TSN_JSON_NEXT_COR_INI
|
| }
|
| else
|
| {
|
| sp++;
|
| (*m_pos) = n;
|
| m_next = TSN_JSON_TOK_LLAVE_END;
|
| }
|
|
|
| //---
|
| break;
|
| }
|
| // tema de ends ya lo scaa en next el sp
|
| case TSN_JSON_TOK_LLAVE_END:
|
| case TSN_JSON_TOK_COR_END:
|
| {
|
| //---
|
| //sp++;
|
|
|
| //---
|
| 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] |= int64_t(m_stak_num[m_stak_curr]) << TSN_SBL_BIT_START_NUM_EL | int64_t((*m_cinta_pos) - lp) << TSN_SBL_BIT_START_NUM_C;
|
| m_cinta[lp + 1] |= int64_t((*m_pos)) << TSN_JSON_BIT_END_T;
|
|
|
| //---
|
| //m_stak_curr--;
|
|
|
| //---
|
| if(--m_stak_curr < 0)
|
| return true;
|
|
|
| //---
|
| m_stak_curr_state = m_stak_state[m_stak_curr];
|
|
|
| //---
|
| (*m_pos)++;
|
|
|
| //---
|
| JSONPARSERBYLEO_FULL_NEXT
|
|
|
| //---
|
| break;
|
| }
|
|
|
| //---
|
| default:
|
| {
|
| *m_last_err = TSN_JSON_ERR_INVALID_CHAR;
|
| return false;
|
| }
|
| }
|
| }
|
|
|
| //---
|
| *m_last_err = TSN_JSON_ERR_JSON_NOT_FINISH;
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
