derivato da koros0111/BasesParserSLan
//+------------------------------------------------------------------+
| |
//| Asm.mqh |
| |
//| Copyright 2026, Niquel Mendoza. |
| |
//| https://www.mql5.com |
| |
//+------------------------------------------------------------------+
| |
#property copyright "Copyright 2026, Niquel Mendoza."
| |
#property link "https://www.mql5.com"
| |
#property strict
| |
| |
#ifndef BASESPARSERSLAN_SRC_QUERY_ASM_MQH
| |
#define BASESPARSERSLAN_SRC_QUERY_ASM_MQH
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
#include "Parser.mqh"
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
#define TSN_DOMPATH_ASMPARSE_TYPE_HASH 4
| |
| |
//+------------------------------------------------------------------+
| |
//----
| |
#define TSN_DOMPATH_INIT_BUSQEUDA_INS_MAIN \
| |
uchar _c = m_raw[m_pos]; \
| |
while(_c < 33) { _c = m_raw[++m_pos]; } \
| |
m_next = g_dompath_asm_toks[_c]; \
| |
if((m_p_f & (1 << m_next)) == 0) \
| |
{ \
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_MALFORMERD_ASM; \
| |
return false; \
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
// Luego de insutrccion busqueda base..
| |
#define TSN_DOMPATH_INIT_BUSQEUDA_INS \
| |
m_p_f = m_pila_ins[m_pila_curr] | ASM_PARSER_TOKF_COMMENT; \
| |
TSN_DOMPATH_INIT_BUSQEUDA_INS_MAIN
| |
| |
| |
//+------------------------------------------------------------------+
| |
#define TSN_DOMPATH_ASMPARSE_CHECK_VALUE \
| |
m_pila_curr++; \
| |
if(m_pila_curr < m_pila_ins_t) \
| |
{ \
| |
TSN_DOMPATH_INIT_BUSQEUDA_INS \
| |
} \
| |
else \
| |
m_next = ASM_PARSER_TOK_PARSE_END;
| |
| |
//+------------------------------------------------------------------+
| |
//--- Lugeo de terminar una instruccion buscamos mas tokens...
| |
#define TSN_DOMPATH_ASMPARSER_NEXT_TOKS \
| |
while(true)\
| |
{\
| |
const uchar _c = m_raw[m_pos];\
| |
if(_c < 33)\
| |
{\
| |
if(++m_pos>=m_len)\
| |
{\
| |
m_last_err_parse=ASM_DOMPATH_PARSER_ERR_DOC_DEBE_DE_CERRAR_CON_SALIDA; \
| |
return true;\
| |
}\
| |
continue;\
| |
}\
| |
m_next = g_dompath_asm_toks[_c];\
| |
if((ASM_PARSER_ALL_VALID_NORMAL & (1 << m_next)) == 0)\
| |
{\
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_MALFORMERD_ASM_CTX_GEN;\
| |
return false;\
| |
}\
| |
break;\
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
#define TSN_DOMPATH_ASM_CHECK_R_PHASHES \
| |
if(m_pendings_hashes_s >= m_pendings_hashes_r) \
| |
{ \
| |
m_pendings_hashes_r <<= 1; \
| |
ArrayResize(m_pendings_hashes, m_pendings_hashes_r, m_pendings_hashes_r); \
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//--- Resuelve un jump ya (si el alias ya fue visto) o lo encola como pendiente
| |
#define TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(HASH_VAL, SLOT_POS, OPINDEX) \
| |
{ \
| |
int _jump_out; \
| |
const ulong _temp = (ulong)HASH_VAL; \
| |
if(!m_hash_jumps.TryGet(_temp, _jump_out)) \
| |
{ \
| |
m_pendings_hashes[m_pendings_hashes_s].bytecode_pos = (SLOT_POS); \
| |
m_pendings_hashes[m_pendings_hashes_s].hash = _temp; \
| |
m_pendings_hashes[m_pendings_hashes_s].mask = g_dompath_op_codes[(OPINDEX)].mask; \
| |
m_pendings_hashes[m_pendings_hashes_s++].bit_start_mask = g_dompath_op_codes[(OPINDEX)].bit_start; \
| |
TSN_DOMPATH_ASM_CHECK_R_PHASHES \
| |
} \
| |
else \
| |
{ \
| |
m_bytecode[(SLOT_POS)] |= long(_jump_out) << g_dompath_op_codes[(OPINDEX)].bit_start; \
| |
} \
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//--- iteracion de un numero
| |
#define TSN_DOMPATH_ITER_N(V) \
| |
STRCONV_TOV_ALG(V, ch) \
| |
if((ch = m_raw[++m_pos] ^ '0') > 9) \
| |
break;
| |
| |
//---
| |
#define TSN_DOMPATH_ARM_ITERNUM_UNROLLED_8(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V) \
| |
TSN_DOMPATH_ITER_N(V)
| |
| |
//---
| |
#define TSN_DOMPATH_ARM_ITERNUM_UNROLLED_17(V) \
| |
TSN_DOMPATH_ARM_ITERNUM_UNROLLED_8(V) \
| |
TSN_DOMPATH_ARM_ITERNUM_UNROLLED_8(V) \
| |
TSN_DOMPATH_ITER_N(V)
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
// ASM
| |
template <typename TBackend>
| |
bool CTSNSLDomQueryCompiler::CompileAsm(void)
| |
{
| |
//---
| |
m_pos = m_offset;
| |
m_pila_curr = 0;
| |
m_pila_v_s = 0;
| |
m_p_f = 0;
| |
m_pendings_hashes_s = 0;
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_NOT;
| |
m_sreg_s = 0; // Se resetea.. el pool de strigns empezamos de 0
| |
m_hash_jumps.Clear();
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSER_NEXT_TOKS
| |
| |
//---
| |
while(true)
| |
{
| |
switch(m_next)
| |
{
| |
case ASM_PARSER_TOK_REGISTER: // R0
| |
{
| |
// Avanzamos exacto
| |
m_pos += 4; // %[r][e][g][aqui]
| |
| |
//--- Rellenamos la pila
| |
// numero puro primero
| |
m_pila_ins[0] = ASM_PARSER_TOKF_NUMBER;
| |
// soporta eq primero
| |
m_pila_ins[1] = ASM_PARSER_TOKF_EQ;
| |
// luego busca un valor
| |
m_pila_ins[2] = ASM_PARSER_TOKF_TRUE | ASM_PARSER_TOKF_NUMBER |
| |
ASM_PARSER_TOKF_FALSE | ASM_PARSER_TOKF_STR | ASM_PARSER_TOKF_S_STR;
| |
// luego tambien hace el registro final
| |
m_pila_ins[3] = DOMPATH_QUERY_INS_TYPE_REG;
| |
m_pila_ins_t = 3;
| |
| |
//--- Siguientes instrucciones
| |
TSN_DOMPATH_INIT_BUSQEUDA_INS
| |
break;
| |
}
| |
case ASM_PARSER_TOK_NUMBER:
| |
{
| |
//---
| |
long v = 0;
| |
| |
//--- Validamos signo
| |
long mask = 0;
| |
uchar ch = m_raw[m_pos] ^ '0';
| |
if(ch == '-')
| |
{
| |
mask = -1;
| |
ch = m_raw[++m_pos] ^ '0';
| |
}
| |
| |
//---
| |
switch(0)
| |
{
| |
default:
| |
{
| |
TSN_DOMPATH_ITER_N(v)
| |
if(!v) // leading
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_LEADING_ZEROS;
| |
m_next = ASM_PARSER_TOK_INVALID;
| |
continue;
| |
}
| |
TSN_DOMPATH_ARM_ITERNUM_UNROLLED_17(v)
| |
STRCONV_TOV_ALG(v, ch)
| |
if((ch = m_raw[++m_pos] ^ '0') > 9)
| |
{
| |
if(v > 0)
| |
break;
| |
}
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_OVERFLOW_INT;
| |
m_next = ASM_PARSER_TOK_INVALID;
| |
continue;
| |
}
| |
}
| |
| |
//---
| |
if(STRCONV_DECX_CH_IS_DEC(ch))
| |
{
| |
//---
| |
int exponente = 0;
| |
if(STRCONV_DECX_CH_IS_PDEC(ch))
| |
{
| |
int ds = ++m_pos; // inicio
| |
if((ch = m_raw[m_pos] ^ '0') > 9)
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_EXPECTED_VAL_AFTER_DECIMALP;
| |
return false;
| |
}
| |
switch(0)
| |
{
| |
default:
| |
{
| |
TSN_DOMPATH_ARM_ITERNUM_UNROLLED_17(v)
| |
TSN_DOMPATH_ITER_N(v)
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_OVERFLOW_INT;
| |
m_next = ASM_PARSER_TOK_INVALID;
| |
continue;
| |
}
| |
}
| |
exponente -= (m_pos - ds);
| |
}
| |
if(STRCONV_DECX_CH_IS_E(ch)) //
| |
{
| |
bool exp_positivo = true;
| |
ch = m_raw[++m_pos] ^ '0';
| |
if(ch > 9)
| |
{
| |
if(STRCONV_DECX_CH_IS_MINUS(ch))
| |
exp_positivo = false;
| |
if((ch = m_raw[++m_pos] ^ '0') > 9)
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_EXPECTED_NUMBER_AFECTER_EXP;
| |
return false; // sale
| |
}
| |
}
| |
//---
| |
int expo = 0;
| |
//---
| |
switch(0) // siguimos acomulando en v
| |
{
| |
default:
| |
{
| |
TSN_DOMPATH_ITER_N(expo)
| |
if(expo == 0) // leading zeros.. ahora mismo aun hay digitos pero el primero es 0..
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_LEADING_ZEROS;
| |
m_next = ASM_PARSER_TOK_INVALID;
| |
continue;
| |
}
| |
TSN_DOMPATH_ARM_ITERNUM_UNROLLED_8(expo)
| |
STRCONV_TOV_ALG(expo, ch)
| |
if((ch = m_raw[++m_pos] ^ '0') > 9) // 10cimo digito
| |
{
| |
if(expo > 0) // es valido
| |
break; // no ov
| |
}
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_OVERFLOW_INT;
| |
m_next = ASM_PARSER_TOK_INVALID;
| |
continue;
| |
}
| |
}
| |
exponente += exp_positivo ? expo : -expo;
| |
}
| |
| |
//--- clamp
| |
if(exponente < -22)
| |
exponente = -22;
| |
else
| |
if(exponente > 22)
| |
exponente = 22;
| |
| |
//--- puede haber overflow con v pero ya dije como es la SPEC
| |
TSN::TsnBitInterprete bit;
| |
bit.double_value = STRCONV_TO_DOUBLE_ALG(exponente, v);
| |
m_pila_v[m_pila_v_s] = bit.long_value;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_FLT;
| |
}
| |
else
| |
{
| |
m_pila_v[m_pila_v_s] = (v ^ mask) - mask;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_INT;
| |
}
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
case ASM_PARSER_TOK_TRUE:
| |
{
| |
m_pos += 4;
| |
m_pila_v[m_pila_v_s] = 1;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_BOL;
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
case ASM_PARSER_TOK_FALSE:
| |
{
| |
m_pos += 5;
| |
m_pila_v[m_pila_v_s] = 0;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_BOL;
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
case ASM_PARSER_TOK_STRING:
| |
{
| |
//---
| |
m_pos++; // luego del S
| |
const int start = ++m_pos;
| |
| |
//----
| |
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_pila_v[m_pila_v_s] = (long)start | long(m_pos - start) << 32;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_STR;
| |
| |
//---
| |
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;
| |
| |
//---
| |
if(qt_final != 0) // Hay un qt real de cierre
| |
{
| |
// Avanzamos y cerramos..
| |
m_pos += TSN::g_tsntables_table_ctz_i8[qt_final];
| |
m_pila_v[m_pila_v_s] = (long)start | long(m_pos - start) << 32;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_STR;
| |
| |
//----
| |
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
| |
}
| |
}
| |
}
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
| |
//---
| |
case ASM_PARSER_TOK_S_STRING:
| |
{
| |
const int start = ++m_pos;
| |
while(true)
| |
{
| |
const uchar c = m_raw[m_pos];
| |
if(c == '\\')
| |
{
| |
m_pos += 2;
| |
continue;
| |
}
| |
if(c == '"')
| |
{
| |
// STRING 1 slot: [tipo(4)|len(28low)|start(32high)]
| |
m_pila_v[m_pila_v_s] = (long)start | long(m_pos - start) << 32;
| |
m_pila_v_t[m_pila_v_s++] = DOMPATHV_TYPE_STR;
| |
m_pos++;
| |
break;
| |
}
| |
m_pos++;
| |
}
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
| |
case ASM_PARSER_TOK_EQ:
| |
{
| |
// Ahora mismo en =
| |
m_pos++;
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
| |
//-- Hash de un jump '' un jump es ascci puro se come "todo tal cual"
| |
case ASM_PARSER_TOK_STR_HASH:
| |
{
| |
// JUMP Hash "hola"
| |
ulong jump_hash = 14695981039346656037ULL;
| |
const uchar cierre = m_raw[m_pos++]; // luego del "
| |
uchar _c = m_raw[m_pos];
| |
| |
//---
| |
while(true)
| |
{
| |
//---
| |
jump_hash ^= _c;
| |
jump_hash *= 1099511628211ULL;
| |
| |
//---
| |
m_pos++;
| |
if(m_pos >= m_len)
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_STR_HASH_NOT_CLOSED;
| |
return false;
| |
}
| |
| |
//---
| |
_c = m_raw[m_pos];
| |
if(_c == cierre)
| |
break;
| |
}
| |
| |
//---
| |
m_pila_v[m_pila_v_s] = (long)jump_hash;
| |
m_pila_v_t[m_pila_v_s++] = TSN_DOMPATH_ASMPARSE_TYPE_HASH;
| |
| |
//---
| |
m_pos++; // luego
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
case ASM_PARSER_TOK_PARSE_KEY_HASH:
| |
{
| |
//---
| |
m_pos += 2; // luego del K, ahjora mismo en "
| |
| |
//--- Aqui llamar al backend para uqe trate la key
| |
ulong hash;
| |
if(!TSN::CBSFLUnescape::MakeHash<TBackend>(m_raw, m_pos, m_len, hash))
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_BACKEND_INVALID_KEY;
| |
return false;
| |
}
| |
| |
//---
| |
m_pila_v[m_pila_v_s] = (long)hash;
| |
m_pila_v_t[m_pila_v_s++] = TSN_DOMPATH_ASMPARSE_TYPE_HASH;
| |
| |
//---
| |
TSN_DOMPATH_ASMPARSE_CHECK_VALUE
| |
break;
| |
}
| |
| |
case ASM_PARSER_TOK_COMMENT:
| |
{
| |
//---
| |
m_pos++; // luego de su valor
| |
| |
//--- Swar para buscar el \n
| |
while(true)
| |
{
| |
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 = chunk ^ TSNTABLES_SWAR_MASK_NEW_LINE;
| |
const ulong has_x = TSNTABLES_SWAR_HAS(x);
| |
| |
//---
| |
if(has_x == 0)
| |
{
| |
m_pos += 8;
| |
continue;
| |
}
| |
| |
//---
| |
const ulong flag_real = TSNTABLES_BIT_DEJAR_SOLO_MINUS_SIG_BYTE(has_x);
| |
m_pos += TSNTABLES_CTZ_64_GET_BYTE(flag_real); // ya en \n
| |
m_pos++; // siguiente
| |
| |
//---
| |
break;
| |
}
| |
| |
//--- Siguiente.
| |
if(m_p_f == 0)
| |
{
| |
// Nada no estamos asi que buscamos con normalidad tokens
| |
TSN_DOMPATH_ASMPARSER_NEXT_TOKS
| |
}
| |
else
| |
{
| |
// Si no es 0 es pro qeu etamos en una cadena de insturcciones asi qeu lo usamos...
| |
TSN_DOMPATH_INIT_BUSQEUDA_INS_MAIN
| |
}
| |
| |
//---
| |
break;
| |
}
| |
| |
//---
| |
case ASM_PARSER_TOK_PARSE_INS:
| |
{
| |
//--- Key it..
| |
ulong key_hash = 14695981039346656037ULL;
| |
do
| |
{
| |
key_hash ^= m_raw[m_pos];
| |
key_hash *= 1099511628211ULL;
| |
m_pos++;
| |
}
| |
while(m_raw[m_pos] > 32);
| |
| |
//---
| |
m_pos++; // luego
| |
| |
//--- Obtenemos el indice
| |
const int index = (int)TSN::DomPathExtBSPLF(key_hash);
| |
//Print("iNDICE: ", index);
| |
if(index == -1) // fallo
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_INVALID_INSTRUCTION;
| |
return false;
| |
}
| |
| |
// Ahora que ya tenemos el indice
| |
m_pila_ins_t = g_dompath_op_codes[index].len;
| |
if(m_pila_ins_t <= 1) // Solo 1 instruccion directo al ulitmo..
| |
{
| |
m_pila_ins[m_pila_curr] = g_dompath_op_codes[index].ops[0]; // directo
| |
m_next = ASM_PARSER_TOK_PARSE_END; // Directo end..
| |
}
| |
else
| |
{
| |
// Mas de 1 rellenamos la pila
| |
for(int i = 0; i < m_pila_ins_t; i++)
| |
m_pila_ins[i] = g_dompath_op_codes[index].ops[i];
| |
// Llenamos de instrucciones
| |
m_pila_ins_t--; // quitamos la ultima (para que curr respete)
| |
| |
//--- Siguiente token
| |
TSN_DOMPATH_INIT_BUSQEUDA_INS
| |
}
| |
break;
| |
}
| |
| |
case ASM_PARSER_TOK_PARSE_END:
| |
{
| |
//---
| |
const uint ins = m_pila_ins[m_pila_curr]; // Ultima
| |
//Print(EnumToString((ENUM_DOMPATH_QUERY_INS_TYPE)ins));
| |
m_bytecode[m_bytecode_s] = ins; // type en 8
| |
switch(ins)
| |
{
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY:
| |
{
| |
// v[0] = hash jump (alias @Alias) | v[1] = hash key ("key")
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[0], m_bytecode_s, ins)
| |
m_bytecode[++m_bytecode_s] = m_pila_v[1]; // hash key completo (64 bits, slot propio)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY_F:
| |
{
| |
// 0 type | 1 = guardamos el hash completo
| |
m_bytecode[++m_bytecode_s] = m_pila_v[0];
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX:
| |
{
| |
// v[0] = index | v[1] = jump hash. Layout slot0: [type|Index=28|Jump=28]
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE;
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[1], m_bytecode_s, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX_F:
| |
{
| |
// Indice luego del type
| |
m_bytecode[m_bytecode_s++] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_INICIAR_ITERACION:
| |
{
| |
// Tipo permitido luego del type
| |
m_bytecode[m_bytecode_s++] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ITER_ASSING:
| |
{
| |
// v[0] = jump hash. Layout: [type|JumpCuandoTermina=28]
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[0], m_bytecode_s, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_EXIST:
| |
{
| |
// v[0] = jump hash | v[1] = hash key completo (64 bits, slot propio)
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[0], m_bytecode_s, ins)
| |
m_bytecode[++m_bytecode_s] = m_pila_v[1];
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_SAVE:
| |
case DOMPATH_QUERY_INS_TYPE_SAVE_NO_RESET:
| |
{
| |
// v[0] = indice de registro | v[1] = jump hash. Layout: [type|IndexRegistro=28|JumpFailed=28]
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE;
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[1], m_bytecode_s, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
| |
//--- math: v[0]=B, v[1]=C, v[2]=A(destino), v[3]=jump
| |
// Layout: slot0=[type|B=28|C=28] slot1=[A=28|JumpFailed=28]
| |
case DOMPATH_QUERY_INS_TYPE_M_MUL:
| |
case DOMPATH_QUERY_INS_TYPE_M_RES:
| |
case DOMPATH_QUERY_INS_TYPE_M_DIV:
| |
case DOMPATH_QUERY_INS_TYPE_M_SUM:
| |
case DOMPATH_QUERY_INS_TYPE_M_MOD:
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_OR:
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_AND:
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_XOR:
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_IZQ:
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_DRC:
| |
{
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE; // B
| |
m_bytecode[m_bytecode_s] |= m_pila_v[1] << TSN_DOMPATH_INS_MATH_BIT_START_REG_2; // C
| |
const int slot2 = ++m_bytecode_s;
| |
m_bytecode[slot2] = m_pila_v[2]; // A (destino), bits bajos
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[3], slot2, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
| |
// unary: v[0]=B, v[1]=jump, v[2]=A(destino)
| |
// Layout: slot0=[type|B=28|Jump=28] slot1=[A=28]
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_NOT:
| |
case DOMPATH_QUERY_INS_TYPE_M_UNARY_NOT:
| |
{
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE; // B
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[1], m_bytecode_s, ins)
| |
m_bytecode[++m_bytecode_s] = m_pila_v[2]; // A (destino)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
| |
// cmp: v[0]=B, v[1]=C, v[2]=esperado(bool), v[3]=jump
| |
// Layout: slot0=[type|B=28|C=28] slot1=[esperado=1|JumpFailed=28]
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_EQ:
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR:
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR_EQ:
| |
{
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE; // B
| |
m_bytecode[m_bytecode_s] |= m_pila_v[1] << TSN_DOMPATH_INS_MATH_BIT_START_REG_2; // C
| |
const int slot2 = ++m_bytecode_s;
| |
m_bytecode[slot2] = m_pila_v[2] & TSN_DOMPATH_BIT_INS_MASK_CMP; // esperado (bit 0)
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[3], slot2, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
| |
// is: v[0]=k(reg), v[1]=jump, v[2]=esperado
| |
// Layout: slot0=[type|RegistroIndex=28|JumpFailid=28] slot1=[1=Esperado]
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_IS:
| |
{
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE; // k
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[1], m_bytecode_s, ins)
| |
m_bytecode[++m_bytecode_s] = m_pila_v[2]; // esperado
| |
m_bytecode_s++;
| |
break;
| |
}
| |
| |
case DOMPATH_QUERY_INS_TYPE_CALL:
| |
{
| |
// v[0]=reg destino, v[1]=nargs, v[2]=nombre funcion
| |
m_bytecode[m_bytecode_s] |= m_pila_v[0] << TSN_DOMPATH_BIT_INS_ETYPE; // reg destino
| |
m_bytecode[m_bytecode_s] |= m_pila_v[1] << TSN_DOMPATH_BIT_INS_BIT_START_NARGS; // nargs
| |
// buscamos en el hash map
| |
if(!m_hash_func.ContainsKeyByHash((ulong)m_pila_v[2]))
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_FUNCTION_NOT_EXIST;
| |
return false;
| |
}
| |
const uint index = m_hash_func.m_last_pos_tbl; // posicion en la tabla
| |
m_bytecode[++m_bytecode_s] = m_hash_func.m_table[index].value;
| |
m_bytecode_s++;
| |
break;
| |
}
| |
| |
case DOMPATH_QUERY_INS_TYPE_RESERVE:
| |
break; // No pide namas es del acutal solo mueve valor..
| |
| |
case DOMPATH_QUERY_INS_TYPE_SLICING:
| |
{
| |
// v[0]=jump, v[1]=start, v[2]=end, v[3]=step
| |
// Layout: slot0=[type|Jump=28|Start=28] slot1=[End=28|Step=28]
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[0], m_bytecode_s, ins)
| |
m_bytecode[m_bytecode_s] |= m_pila_v[1] << TSN_DOMPATH_BIT_INS_BIT_START_SLSTART; // start
| |
const int slot2 = ++m_bytecode_s;
| |
m_bytecode[slot2] = m_pila_v[2] & TSN_DOMPATH_BIT_INS_MASK_SLMASK; // end
| |
m_bytecode[slot2] |= m_pila_v[3] << TSN_DOMPATH_BIT_INS_BIT_START_SLPASO; // step
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_JUMP:
| |
{
| |
// v[0] = jump hash (incondicional)
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[0], m_bytecode_s, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_COPY_ALL:
| |
{
| |
// v[0] = jump hash (si m_curr no es array)
| |
TSN_DOMPATH_ASM_RESOLVE_OR_QUEUE_JUMP(m_pila_v[0], m_bytecode_s, ins)
| |
m_bytecode_s++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_APPEND:
| |
m_bytecode_s++;
| |
break;
| |
| |
case DOMPATH_QUERY_INS_TYPE_SALIDA:
| |
{
| |
//--- Por alguna razon es mayor por ejelplo "" no cerrado y se colo por ahi
| |
if(m_pos >= m_len)
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_ASM_END_BUT_IS_MALFORMED;
| |
return false;
| |
}
| |
| |
//--- Iteramos por todos los pendientes..
| |
for(int i = 0; i < m_pendings_hashes_s; i++)
| |
{
| |
int out;
| |
if(!m_hash_jumps.TryGet(m_pendings_hashes[i].hash, out))
| |
{
| |
// No existe
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_INVALID_JUMP_KEY;
| |
return false;
| |
}
| |
const int k = m_pendings_hashes[i].bytecode_pos;
| |
m_bytecode[k] =
| |
(m_bytecode[k] & m_pendings_hashes[i].mask) | // limpaimos y dejamos los bits de la mascara en 0
| |
(long(out) << m_pendings_hashes[i].bit_start_mask); // a esos bits le damos su valor..
| |
}
| |
| |
//---
| |
m_bytecode_s++;
| |
return true; // Salimos directo
| |
}
| |
| |
//--- Creamos un registro
| |
case DOMPATH_QUERY_INS_TYPE_REG:
| |
{
| |
// toma el valor de la pila 0 y 1 para hacer su valor
| |
// 0 siempre es integer
| |
const int i = (int)m_pila_v[0];
| |
m_reg[i].tt = m_pila_v_t[1];
| |
switch(m_pila_v_t[1])
| |
{
| |
case DOMPATHV_TYPE_BOL:
| |
{
| |
m_reg[i].v.bv = m_pila_v[1] != 0;
| |
break;
| |
}
| |
case DOMPATHV_TYPE_INT:
| |
{
| |
m_reg[i].v.iv = m_pila_v[1];
| |
break;
| |
}
| |
case DOMPATHV_TYPE_FLT:
| |
{
| |
TSN::TsnBitInterprete bit;
| |
bit.long_value = m_pila_v[1];
| |
m_reg[i].v.dv = bit.double_value;
| |
break;
| |
}
| |
case DOMPATHV_TYPE_STR:
| |
{
| |
const int idx = NewStringIndex();
| |
if(!TSN::CBSFLUnescape::MakeString<TBackend>(m_raw, int(m_pila_v[1] & 0xfffffff), int(m_pila_v[1] >> 32), m_sreg[idx]))
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_BACKEND_INVALID_STRING;
| |
return false;
| |
}
| |
m_reg[i].v.ix = idx;
| |
break;
| |
}
| |
default:
| |
break;
| |
}
| |
| |
//---
| |
break;
| |
}
| |
| |
default:
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_INVALID_CASE_INS;
| |
return false;
| |
}
| |
| |
//--- Reseteamos todo..
| |
m_pila_v_s = 0;
| |
m_pila_curr = 0;
| |
m_p_f = 0;
| |
| |
//--- Buscamos mas tokens
| |
TSN_DOMPATH_ASMPARSER_NEXT_TOKS
| |
| |
//---
| |
break;
| |
}
| |
| |
case ASM_PARSER_TOK_PARSE_JUMP_S:
| |
{
| |
m_pos++; // luego de @
| |
ulong jump_hash = 14695981039346656037ULL;
| |
| |
//---
| |
while(true)
| |
{
| |
//---
| |
jump_hash ^= m_raw[m_pos];
| |
jump_hash *= 1099511628211ULL;
| |
m_pos++;
| |
| |
//---
| |
if(m_raw[m_pos] == ':')
| |
{
| |
// Siguiente es espacio
| |
if(m_raw[m_pos + 1] < 33)
| |
{
| |
m_pos++; // ahora en ws
| |
break; // sale
| |
}
| |
else
| |
{
| |
// No entonces haseamos el actual.
| |
jump_hash ^= ':';
| |
jump_hash *= 1099511628211ULL;
| |
m_pos++; // Siguiente.
| |
}
| |
}
| |
| |
//---
| |
if(m_pos >= m_len)
| |
{
| |
m_last_err_parse = ASM_DOMPATH_PARSER_ERR_JUMP_NOT_CLOSED;
| |
return false;
| |
}
| |
}
| |
| |
//---
| |
m_hash_jumps.Add(jump_hash, m_bytecode_s); // Siguiente..
| |
| |
//--- Buscamos mas toks
| |
TSN_DOMPATH_ASMPARSER_NEXT_TOKS
| |
break;
| |
}
| |
| |
//--- Err
| |
// Esto casi que es imposible que ocrura dado que en todas las transiciones
| |
// siempre se vigia su vlaor aparte la iteracion inical igual...
| |
default:
| |
return false;
| |
}
| |
| |
}
| |
}
| |
//+------------------------------------------------------------------+
| |
#endif // BASESPARSERSLAN_SRC_QUERY_ASM_MQH
| |
//+------------------------------------------------------------------+
|