forked from koros0111/BasesParserSLan
//+------------------------------------------------------------------+
| |
//| Query.mqh |
| |
//| Copyright 2026, Nique. |
| |
//| https://www.mql5.com |
| |
//+------------------------------------------------------------------+
| |
#property copyright "Copyright 2026, Nique."
| |
#property link "https://www.mql5.com"
| |
#property strict
| |
| |
#ifndef BASESPARSERSLAN_SRC_QUERY_QUERY_MQH
| |
#define BASESPARSERSLAN_SRC_QUERY_QUERY_MQH
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
#include "Asm.mqh"
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
namespace TSN
| |
{
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
class CSLDomQueryVm : public CTSNSLDomQueryCompiler
| |
{
| |
private:
| |
//--- Iteracion
| |
//- ambos (que tipos se aceptan)
| |
uchar m_stack_it_types[TSN_DOMPATH_MAX_DEPTH_ITER];
| |
| |
//- iteracion de obj
| |
CHashMapFastIterator(string, CDomNodeBase*) m_stack_it_obj[TSN_DOMPATH_MAX_DEPTH_ITER];
| |
| |
//- iteracion de array
| |
CDomNodeManager* m_stack_it_ptr[TSN_DOMPATH_MAX_DEPTH_ITER]; // Punteros de manager
| |
int m_stack_it_k[TSN_DOMPATH_MAX_DEPTH_ITER]; // k (vlaor acutal de itacion)
| |
int m_stack_it_count[TSN_DOMPATH_MAX_DEPTH_ITER]; // numero de elementos restantes.
| |
int m_stack_it_ix[TSN_DOMPATH_MAX_DEPTH_ITER]; // indice en m_ctx.m_nodes
| |
| |
//- indice de la iteracion actual
| |
int m_stack_it_curr;
| |
| |
//--- Registros de nodes
| |
CDomNodeBase* m_dnodes[TSN_DOMPATH_MAX_SIZE_DNODES];
| |
int m_dnodes_size;
| |
| |
//--- Actual
| |
ulong m_current_hash;
| |
CDomNodeBase* m_curr;
| |
| |
//--- Instrution pointer
| |
int m_ip;
| |
| |
//---
| |
CDomNodeBase* m_base_node;
| |
| |
public:
| |
//--- Call frame actual
| |
int m_num_args;
| |
int m_reg_start_params;
| |
| |
//--- Objeto actual
| |
int m_el_s;
| |
int m_el_r;
| |
| |
public:
| |
CSLDomQueryVm(void) {}
| |
~CSLDomQueryVm(void) {}
| |
| |
//--- Metodo base
| |
bool Run(CDomNodeBase* &elemts[]);
| |
| |
//---
| |
void BaseNode(CDomNodeBase* base) { m_base_node = base; }
| |
CDomNodeBase* BaseNode() { return m_base_node; }
| |
| |
//--- Funciones
| |
// Leer
| |
template <typename T>
| |
__forceinline T FReadIntegerAs(int param_index);
| |
__forceinline double FReadDouble(int param_index);
| |
__forceinline string FReadString(int param_index);
| |
__forceinline bool FReadBool(int param_index);
| |
CDomNodeBase* FReadNode(int param_index);
| |
| |
// Pusearh un valor a los registros
| |
template <typename T>
| |
void FPushInteger(T v);
| |
void FPushValue(double v);
| |
void FPushValue(bool v);
| |
void FPushValue(const string& v);
| |
};
| |
| |
//+------------------------------------------------------------------+
| |
//| Read |
| |
//+------------------------------------------------------------------+
| |
template <typename T>
| |
__forceinline T CSLDomQueryVm::FReadIntegerAs(int param_index)
| |
{
| |
return (T)m_reg[m_reg_start_params + param_index].v.iv;
| |
}
| |
//+------------------------------------------------------------------+>
| |
__forceinline bool CSLDomQueryVm::FReadBool(int param_index)
| |
{
| |
return m_reg[m_reg_start_params + param_index].v.bv;
| |
}
| |
//+------------------------------------------------------------------+>
| |
__forceinline double CSLDomQueryVm::FReadDouble(int param_index)
| |
{
| |
return m_reg[m_reg_start_params + param_index].v.dv;
| |
}
| |
//+------------------------------------------------------------------+>
| |
__forceinline string CSLDomQueryVm::FReadString(int param_index)
| |
{
| |
return m_sreg[m_reg[m_reg_start_params + param_index].v.ix];
| |
}
| |
//+------------------------------------------------------------------+>
| |
__forceinline CDomNodeBase* CSLDomQueryVm::FReadNode(int param_index)
| |
{
| |
return m_dnodes[m_reg[m_reg_start_params + param_index].v.ix];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Push |
| |
//+------------------------------------------------------------------+
| |
void CSLDomQueryVm::FPushValue(bool v)
| |
{
| |
m_reg[m_reg_s].tt = DOMPATHV_TYPE_BOL;
| |
m_reg[m_reg_s++].v.bv = v;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
void CSLDomQueryVm::FPushValue(double v)
| |
{
| |
m_reg[m_reg_s].tt = DOMPATHV_TYPE_FLT;
| |
m_reg[m_reg_s++].v.dv = v;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
template <typename T>
| |
void CSLDomQueryVm::FPushInteger(T v)
| |
{
| |
//Print("new integer: ", v);
| |
m_reg[m_reg_s].tt = DOMPATHV_TYPE_INT;
| |
m_reg[m_reg_s++].v.iv = (long)v;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
void CSLDomQueryVm::FPushValue(const string &v)
| |
{
| |
//---
| |
m_sreg[m_sreg_s] = v;
| |
| |
//---
| |
m_reg[m_reg_s].tt = DOMPATHV_TYPE_STR;
| |
m_reg[m_reg_s++].v.ix = m_sreg_s++;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Bloque math |
| |
//+------------------------------------------------------------------+
| |
#define TSN_DOMPATH_DO_MATH_TYPED_PREV(OP) \
| |
const long l = m_bytecode[m_ip];\
| |
const long l2 = m_bytecode[m_ip + 1];\
| |
switch(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].tt)\
| |
{\
| |
case DOMPATHV_TYPE_BOL:\
| |
case DOMPATHV_TYPE_INT:\
| |
{\
| |
switch(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].tt)\
| |
{\
| |
case DOMPATHV_TYPE_BOL:\
| |
case DOMPATHV_TYPE_INT:\
| |
{\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].tt = DOMPATHV_TYPE_INT;\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].v.iv = m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.iv OP m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].v.iv;\
| |
m_ip += 2;\
| |
break;\
| |
}\
| |
case DOMPATHV_TYPE_FLT:\
| |
{\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].tt = DOMPATHV_TYPE_FLT;\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].v.dv = (double)m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.iv\
| |
OP m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].v.dv;\
| |
m_ip += 2;\
| |
break;\
| |
}\
| |
default:\
| |
m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
| |
break;\
| |
}\
| |
break;\
| |
}\
| |
case DOMPATHV_TYPE_FLT:\
| |
{\
| |
switch(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].tt)\
| |
{\
| |
case DOMPATHV_TYPE_BOL:\
| |
case DOMPATHV_TYPE_INT:\
| |
{\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].tt = DOMPATHV_TYPE_INT;\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].v.dv = (double)m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.iv\
| |
OP m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].v.dv;\
| |
m_ip += 2;\
| |
break;\
| |
}\
| |
case DOMPATHV_TYPE_FLT:\
| |
{\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].v.dv = m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.dv\
| |
OP m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].v.dv;\
| |
m_ip += 2;\
| |
break;\
| |
}\
| |
default:\
| |
m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
| |
break;\
| |
}\
| |
break;\
| |
}
| |
| |
| |
//----- All
| |
#define TSN_DOMPATH_DO_MATH_TYPED_ALL(OP) \
| |
TSN_DOMPATH_DO_MATH_TYPED_PREV(OP)\
| |
default:\
| |
{\
| |
m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
| |
break;\
| |
}\
| |
}
| |
| |
//----- Str en especifico
| |
#define TSN_DOMPATH_DO_MATH_TYPED_SUM \
| |
TSN_DOMPATH_DO_MATH_TYPED_PREV(+)\
| |
case DOMPATHV_TYPE_STR:\
| |
{\
| |
if(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].tt!=DOMPATHV_TYPE_STR)\
| |
{\
| |
m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
| |
break;\
| |
}\
| |
m_sreg[m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].v.ix] = m_sreg[m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.ix] + \
| |
m_sreg[m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].v.ix];\
| |
break;\
| |
}\
| |
default:\
| |
m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
| |
break;\
| |
}
| |
| |
| |
//-------------------
| |
#define TSN_DOMPATH_DO_MATH_TYPED_INTEGER(OP) \
| |
const long l = m_bytecode[m_ip];\
| |
const long l2 = m_bytecode[m_ip + 1];\
| |
if((((1 << m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].tt)| (1 << m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].tt)) & (DOMPATHV_F_BOL|DOMPATHV_F_INT))==0)\
| |
{\
| |
m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
| |
}\
| |
else\
| |
{\
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].tt=DOMPATHV_TYPE_INT; \
| |
m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_A(l2)].v.iv = m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.iv OP m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)].v.iv; \
| |
m_ip+=2;\
| |
}
| |
| |
| |
// "a" + @.valor @.valor + "a"
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
// compara registros mismo layout incnial [8][28][28] [1 = expected][28 = jump]
| |
#define TSN_DOMPATH_DO_COMP_TYPED_ALL(B, C, OP) \
| |
switch(B.tt) \
| |
{ \
| |
case DOMPATHV_TYPE_BOL: \
| |
res = (B.v.bv OP (C.tt == DOMPATHV_TYPE_FLT ? (bool)C.v.dv : (bool)C.v.iv)); \
| |
break; \
| |
case DOMPATHV_TYPE_INT: \
| |
res = (B.v.iv OP (C.tt == DOMPATHV_TYPE_FLT ? (long)C.v.dv : C.v.iv)); \
| |
break; \
| |
case DOMPATHV_TYPE_FLT: \
| |
res = (B.v.dv OP (C.tt != DOMPATHV_TYPE_FLT ? (double)C.v.iv : C.v.dv)); \
| |
break; \
| |
case DOMPATHV_TYPE_STR: \
| |
{\
| |
if(C.tt!=DOMPATHV_TYPE_STR)\
| |
break; \
| |
res = m_sreg[B.v.ix] OP m_sreg[C.v.ix]; \
| |
break; \
| |
} \
| |
default: \
| |
break; \
| |
}
| |
| |
//---
| |
#define TSN_DOMPATH_DEFINE_BOOL_OP(OP) \
| |
bool res=false;\
| |
const long l = m_bytecode[m_ip];\
| |
TSN_DOMPATH_DO_COMP_TYPED_ALL(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)], m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_C(l)], OP) \
| |
m_ip++;\
| |
if(res == bool(m_bytecode[m_ip] & TSN_DOMPATH_BIT_INS_MASK_CMP))\
| |
m_ip++;\
| |
else\
| |
m_ip = TSN_DOMPATH_BIT_INS_GET_JUMP(m_bytecode[m_ip]);
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
bool CSLDomQueryVm::Run(CDomNodeBase* &elemts[])
| |
{
| |
//---
| |
m_ip = 0;
| |
m_el_s = 0;
| |
m_el_r = ArrayResize(elemts, 8, 8);
| |
m_stack_it_curr = -1;
| |
| |
//--- Reinicio
| |
m_sreg_s = m_locked_sreg; // Empieza desde ahi
| |
m_dnodes_size = 0; // Tambien de 0
| |
m_curr = m_base_node;
| |
// inicia en mitad por convencion para los dinamicos...
| |
m_reg_s = TSN_DOMPATH_MAX_SIZE_REG >> 1;
| |
| |
//---
| |
while(true)
| |
{
| |
switch(uchar(m_bytecode[m_ip]&TSN_DOMPATH_MASK_INS_TYPE))
| |
{
| |
//--- Acceso
| |
// Acceso normal en iteracion
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY:
| |
{
| |
// [8bit=Type][28bit=a donde saltar instucino ip]
| |
// [64hash=completo]
| |
// accceso directo por hash 64
| |
m_curr = m_curr.Get((ulong)m_bytecode[m_ip + 1]);
| |
if(m_curr == NULL)
| |
{
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
break;
| |
}
| |
// no fallo eotnces slatoams dos
| |
m_ip += 2; // [curr][hash] [aqui]
| |
break;
| |
}
| |
// Acceso F
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY_F:
| |
{
| |
// accceso directo por hash 64
| |
m_curr = m_curr.Get((ulong)m_bytecode[m_ip + 1]);
| |
if(m_curr == NULL)
| |
return false;
| |
// no fallo eotnces slatoams dos
| |
m_ip += 2; // [curr][hash] [aqui]
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX:
| |
{
| |
// [8bit=type][28bit=index][28bit=a donde saltar]
| |
const int i = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_ACCES;
| |
m_curr = m_curr.AtSafe(i); // Acceso
| |
if(m_curr == NULL)
| |
{
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_INS_ACCESO_INDEX_JUMP_BIT_S);
| |
break;
| |
}
| |
m_ip++; // todo bien salta al siguiente
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX_F:
| |
{
| |
// [8bit=type][28bit=index]
| |
m_curr = m_curr.AtSafe(int(m_bytecode[m_ip++] >> TSN_DOMPATH_BIT_INS_ETYPE)); // Acceso
| |
if(m_curr == NULL)
| |
return false; // aqui seria finalizar directo..
| |
m_ip++;
| |
break;
| |
}
| |
| |
//--- Iniciar iteracion
| |
case DOMPATH_QUERY_INS_TYPE_INICIAR_ITERACION:
| |
{
| |
// No reuiqre mas solo type.. [8bit][8bit=qeu aceptamos, 0xff si aceptos de todo]
| |
//---
| |
m_stack_it_curr++;
| |
m_stack_it_types[m_stack_it_curr] = uchar(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
| |
//---
| |
if(m_curr.m_type == TSN_SBL_BASE_TYPE_OBJ)
| |
{
| |
m_stack_it_obj[m_stack_it_curr] = m_curr.BenginIteration();
| |
m_stack_it_count[m_stack_it_curr] = -1;
| |
m_stack_it_k[m_stack_it_curr] = 0;
| |
}
| |
else
| |
{
| |
m_stack_it_ptr[m_stack_it_curr] = m_curr.m_ctx;
| |
m_stack_it_ix[m_stack_it_curr] = m_curr.m_v.ix;
| |
m_stack_it_k[m_stack_it_curr] = 0;
| |
m_stack_it_count[m_stack_it_curr] = m_curr.Size(); // Tamaño de este array
| |
}
| |
| |
//---
| |
m_ip++;
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_ITER_ASSING:
| |
{
| |
// [8bit=type ins][28bit en caso falle saltar a]
| |
const int c = m_stack_it_count[m_stack_it_curr];
| |
if(c == -1) // iteramos sobre un objeto
| |
{
| |
//---
| |
if(m_stack_it_k[m_stack_it_curr] > 0)
| |
m_stack_it_obj[m_stack_it_curr].Next();
| |
| |
//---
| |
if(m_stack_it_obj[m_stack_it_curr].IsValid())
| |
{
| |
//--- En caso sea 0 no.. venimos.. aun tomamos los valores y recien ahi..
| |
m_current_hash = m_stack_it_obj[m_stack_it_curr].Hash();
| |
m_curr = m_stack_it_obj[m_stack_it_curr].Val();
| |
//Print(m_stack_it_obj[m_stack_it_curr].Key());
| |
m_stack_it_k[m_stack_it_curr]++;
| |
}
| |
else // SI no es valido
| |
{
| |
m_stack_it_curr--;
| |
// Saltamos a donde se diga una vez que termine la iteracion
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
break; // de una salimos de aqui
| |
}
| |
}
| |
else
| |
{
| |
if(m_stack_it_k[m_stack_it_curr] < m_stack_it_count[m_stack_it_curr])
| |
{
| |
m_curr = m_stack_it_ptr[m_stack_it_curr].m_node[m_stack_it_ix[m_stack_it_curr]].values[m_stack_it_k[m_stack_it_curr]++];
| |
}
| |
else // Termino..
| |
{
| |
m_stack_it_curr--;
| |
// Saltamos a donde se diga una vez que termine la iteracion
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
break; // de una salimos de aqui
| |
}
| |
}
| |
| |
//--- Ahora verificamos tipo
| |
const uchar t = m_stack_it_types[m_stack_it_curr];
| |
if(t != TSN_DOMPATH_INS_ITER_ALL_TYPES && t != m_curr.m_type) // en caso no coincide
| |
break; // Volvemos a este punto.. denuvo.. (ip no avanza..)
| |
| |
//---
| |
m_ip++;
| |
break;
| |
}
| |
| |
//---
| |
case DOMPATH_QUERY_INS_TYPE_EXIST:
| |
{
| |
// 2 slots
| |
// expectred [type=8|28=JumpInFail][hash=64]
| |
if(m_current_hash != (ulong)m_bytecode[m_ip + 1])
| |
{
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
break;
| |
}
| |
m_ip += 2; // [act][hash][ahora]
| |
break;
| |
}
| |
| |
//--- save basico para nativos
| |
case DOMPATH_QUERY_INS_TYPE_SAVE:
| |
{
| |
// [8type][28=k][28=jump]
| |
const int k = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_REG;
| |
switch(m_curr.m_type)
| |
{
| |
case TSN_SBL_BASE_TYPE_ARR:
| |
{
| |
m_reg[k].tt = DOMPATHV_TYPE_ARR;
| |
m_reg[k].v.ix = m_dnodes_size;
| |
m_dnodes[m_dnodes_size++] = m_curr;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_OBJ:
| |
{
| |
m_reg[k].tt = DOMPATHV_TYPE_OBJ;
| |
m_reg[k].v.ix = m_dnodes_size;
| |
m_dnodes[m_dnodes_size++] = m_curr;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_UINT: // tambien va como iv va aqui
| |
{
| |
m_reg[k].v.iv = (long)m_curr.m_v.uv;
| |
m_reg[k].tt = DOMPATHV_TYPE_INT;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_INT:
| |
{
| |
m_reg[k].v.iv = m_curr.m_v.iv;
| |
m_reg[k].tt = DOMPATHV_TYPE_INT;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_FLT:
| |
{
| |
m_reg[k].v.dv = m_curr.m_v.dv;
| |
m_reg[k].tt = DOMPATHV_TYPE_FLT;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_BOL:
| |
{
| |
m_reg[k].v.bv = m_curr.m_v.bv;
| |
m_reg[k].tt = DOMPATHV_TYPE_BOL;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_STR:
| |
{
| |
m_reg[k].tt = TSN_SBL_BASE_TYPE_STR;
| |
m_reg[k].v.ix = m_sreg_s;
| |
m_sreg[m_sreg_s++] = m_curr.m_ctx.m_string_stack[m_curr.m_v.ix];
| |
break;
| |
}
| |
default:
| |
{
| |
// Nota que solo los valores normales como string\int se guranda en reg
| |
// Los otros como arr tambien pero solo se almacnea us nodo su unica utilidad es para funciones..
| |
// Tipo invalido null
| |
// Aqui un jump a direccion especificada
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START) - 1;
| |
break;
| |
}
| |
}
| |
| |
//---
| |
m_ip++;
| |
| |
//---
| |
// Las insutrccions tipo save tambin indican el final.. de un acceso
| |
// dado que la idea es ir accediendo y luego guarda su valor
| |
// Retrocedemos al valor base de la iteracion...
| |
// Por ahora solo objetos luego veremos la logica para arrays.
| |
m_curr = m_stack_it_obj[m_stack_it_curr].Val();
| |
break;
| |
}
| |
| |
//--- Version 2.. esta no resetea mantiene m_curr donde estuvo
| |
case DOMPATH_QUERY_INS_TYPE_SAVE_NO_RESET:
| |
{
| |
// [8type][28=k][28=jump]
| |
const int k = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_REG;
| |
switch(m_curr.m_type)
| |
{
| |
case TSN_SBL_BASE_TYPE_ARR:
| |
{
| |
m_reg[k].tt = DOMPATHV_TYPE_ARR;
| |
m_reg[k].v.ix = m_dnodes_size;
| |
m_dnodes[m_dnodes_size++] = m_curr;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_OBJ:
| |
{
| |
m_reg[k].tt = DOMPATHV_TYPE_OBJ;
| |
m_reg[k].v.ix = m_dnodes_size;
| |
m_dnodes[m_dnodes_size++] = m_curr;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_UINT: // tambien va como iv va aqui
| |
{
| |
m_reg[k].v.iv = (long)m_curr.m_v.uv;
| |
m_reg[k].tt = DOMPATHV_TYPE_INT;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_INT:
| |
{
| |
m_reg[k].v.iv = m_curr.m_v.iv;
| |
m_reg[k].tt = DOMPATHV_TYPE_INT;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_FLT:
| |
{
| |
m_reg[k].v.dv = m_curr.m_v.dv;
| |
m_reg[k].tt = DOMPATHV_TYPE_FLT;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_BOL:
| |
{
| |
m_reg[k].v.bv = m_curr.m_v.bv;
| |
m_reg[k].tt = DOMPATHV_TYPE_BOL;
| |
break;
| |
}
| |
case TSN_SBL_BASE_TYPE_STR:
| |
{
| |
m_reg[k].tt = TSN_SBL_BASE_TYPE_STR;
| |
m_reg[k].v.ix = m_sreg_s;
| |
m_sreg[m_sreg_s++] = m_curr.m_ctx.m_string_stack[m_curr.m_v.ix];
| |
break;
| |
}
| |
default:
| |
{
| |
// Nota que solo los valores normales como string\int se guranda en reg
| |
// Los otros como arr tambien pero solo se almacnea us nodo su unica utilidad es para funciones..
| |
// Tipo invalido null
| |
// Aqui un jump a direccion especificada
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START) - 1;
| |
break;
| |
}
| |
}
| |
| |
//---
| |
m_ip++;
| |
break;
| |
}
| |
| |
//--- math
| |
// math entero usa 2 slots.. para sus intrucciones
| |
// [type][28][28] | [28] [28]
| |
// 8type 28b 28c 28a 28jump
| |
case DOMPATH_QUERY_INS_TYPE_M_MUL:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_ALL(*)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_RES:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_ALL(-)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_DIV:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_ALL( /)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_SUM:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_SUM
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_MOD:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_INTEGER( %)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_OR:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_INTEGER( |)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_AND:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_INTEGER(&)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_XOR:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_INTEGER(^)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_IZQ:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_INTEGER( <<)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_DRC:
| |
{
| |
TSN_DOMPATH_DO_MATH_TYPED_INTEGER( >>)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_M_BIT_NOT:
| |
{
| |
//---
| |
const long l = m_bytecode[m_ip];
| |
const long l2 = m_bytecode[m_ip + 1];
| |
| |
//---
| |
if(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].tt != DOMPATHV_TYPE_INT)
| |
m_ip = int(m_bytecode[l] >> TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR); // fallo
| |
else
| |
{
| |
m_reg[l2].tt = DOMPATHV_TYPE_INT;
| |
m_reg[l2].v.iv = ~m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.iv;
| |
m_ip += 2;
| |
}
| |
break;
| |
}
| |
| |
//---
| |
case DOMPATH_QUERY_INS_TYPE_M_UNARY_NOT:
| |
{
| |
const long l = m_bytecode[m_ip];
| |
const long l2 = m_bytecode[m_ip + 1];
| |
switch(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].tt)
| |
{
| |
case DOMPATHV_TYPE_BOL:
| |
{
| |
// bool a int
| |
m_reg[l2].tt = DOMPATHV_TYPE_INT;
| |
m_reg[l2].v.iv = -int(m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.bv);
| |
m_ip += 2;
| |
break;
| |
}
| |
case DOMPATHV_TYPE_INT:
| |
{
| |
// bool a int
| |
m_reg[l2].tt = DOMPATHV_TYPE_INT;
| |
m_reg[l2].v.iv = -m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.iv;
| |
m_ip += 2;
| |
break;
| |
}
| |
case DOMPATHV_TYPE_FLT:
| |
{
| |
// bool a int
| |
m_reg[l2].tt = DOMPATHV_TYPE_FLT;
| |
m_reg[l2].v.dv = -m_reg[TSN_DOMPATH_INS_MATH_BIT_GET_B(l)].v.dv;
| |
m_ip += 2;
| |
break;
| |
}
| |
default:
| |
{
| |
// Tipo invalido string, etc..
| |
m_ip = int(l >> TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR); // fallo
| |
break;
| |
}
| |
}
| |
break;
| |
}
| |
| |
//--- Operaciones de compracion
| |
// [type][28][28] | [2][28][1]
| |
//--- Cmp (comparaciones..)
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_EQ:
| |
{
| |
TSN_DOMPATH_DEFINE_BOOL_OP( ==)
| |
//Print("Hola: ", res);
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR:
| |
{
| |
TSN_DOMPATH_DEFINE_BOOL_OP( <)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR_EQ:
| |
{
| |
TSN_DOMPATH_DEFINE_BOOL_OP( <=)
| |
break;
| |
}
| |
case DOMPATH_QUERY_INS_TYPE_COMPARE_IS:
| |
{
| |
//--- [8bytes][KIndex=28][28=Jump] | [1 bit = resultado esperado]
| |
bool res = false;
| |
const int k = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_REG;
| |
| |
switch(m_reg[k].tt)
| |
{
| |
case DOMPATHV_TYPE_BOL:
| |
res = m_reg[k].v.bv;
| |
break;
| |
case DOMPATHV_TYPE_INT:
| |
res = m_reg[k].v.iv != 0;
| |
break;
| |
case DOMPATHV_TYPE_FLT:
| |
res = m_reg[k].v.dv != 0;
| |
break;
| |
case DOMPATHV_TYPE_STR:
| |
res = m_sreg[m_reg[k].v.ix].Length() != 0;
| |
break;
| |
default:
| |
break;
| |
}
| |
| |
//--
| |
//Print("is: ", res, " k: ", k);
| |
| |
//---
| |
m_ip++;
| |
if(res == bool(m_bytecode[m_ip]))
| |
m_ip++; // sigueinte normal
| |
else
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_JUMP_START_CMPIS_FALSE); // saltamos
| |
break;
| |
}
| |
| |
//---
| |
case DOMPATH_QUERY_INS_TYPE_CALL:
| |
{
| |
// [8type][28=direecion donde empieza todo][28 numero de argumentos][Indice de la funcion]
| |
// [indice de funcion] (slot completo)
| |
m_reg_start_params = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_REG;
| |
// los parameotrs van luego de reg out siempre... van en esas direcciones
| |
| |
m_num_args = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_BIT_START_NARGS);
| |
m_ip++;
| |
| |
//---
| |
// Empiza aqui todo... el resultado
| |
const int lock = m_reg_start_params + m_num_args;
| |
| |
//---
| |
m_reg_s = lock + 1;
| |
| |
//---
| |
m_funcs[m_bytecode[m_ip]](&this); // llamamos
| |
//Print("Num:" , (m_reg_s - lock) - 1);
| |
| |
//---
| |
m_reg[lock].tt = DOMPATHV_TYPE_INT;
| |
m_reg[lock].v.iv = (m_reg_s - lock) - 1; // 1 dado qeu empiza...
| |
| |
// ahora ya se sape que la funcion escrbiio un valor en dicho registro
| |
m_ip++; // Siguiente insturccion
| |
break;
| |
}
| |
| |
//---
| |
case DOMPATH_QUERY_INS_TYPE_RESERVE:
| |
{
| |
// Esta insturccion unicamnete incremente el regsize par que el siguiente
| |
// valor donde se ponga dciho valor sea el sigueinte slot.. dado que se reserva este
| |
m_reg_s++;
| |
m_ip++;
| |
break;
| |
}
| |
| |
//--- Slicing cumpleto de array
| |
case DOMPATH_QUERY_INS_TYPE_SLICING:
| |
{
| |
// En total ocupa 2 slots
| |
// [8type | 28=jump | 28=strat]
| |
// [28=end | 28=step]
| |
// En caso no sea array...
| |
// int jump_index = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_REG;
| |
if(m_curr.m_type != TSN_SBL_BASE_TYPE_ARR)
| |
{
| |
// Saltar a la direccion especificada
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE)
| |
& TSN_DOMPATH_INS_MASK_INDEX_JMP;
| |
break;
| |
}
| |
const int s = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_BIT_START_SLSTART);
| |
const long l2 = (m_bytecode[++m_ip]);
| |
const int e = int(l2 & TSN_DOMPATH_BIT_INS_MASK_SLMASK);
| |
const int p = int(l2 >> TSN_DOMPATH_BIT_INS_BIT_START_SLPASO);
| |
m_el_s += m_curr.PySlicing(elemts, m_el_s, s, e, p);
| |
m_ip++;
| |
break;
| |
}
| |
| |
//---
| |
case DOMPATH_QUERY_INS_TYPE_JUMP:
| |
{
| |
// [8byt type][28bit=jump dir]
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
break;
| |
}
| |
| |
//---
| |
case DOMPATH_QUERY_INS_TYPE_COPY_ALL:
| |
{
| |
const int t = m_curr.CopyTo(elemts, m_el_s);
| |
if(t == -1)
| |
{
| |
m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
| |
break;
| |
}
| |
m_el_s += t;
| |
m_ip++;
| |
break;
| |
}
| |
| |
//--- Finaes
| |
case DOMPATH_QUERY_INS_TYPE_APPEND:
| |
{
| |
if(m_el_s + 1 >= m_el_r)
| |
{
| |
m_el_r += (m_el_s << 1) + 8;
| |
ArrayResize(elemts, m_el_r, m_el_r);
| |
}
| |
elemts[m_el_s++] = m_curr; // Actual
| |
m_ip++;
| |
break;
| |
}
| |
| |
case DOMPATH_QUERY_INS_TYPE_SALIDA:
| |
return true;
| |
| |
default:
| |
return false;
| |
}
| |
}
| |
| |
//---
| |
}
| |
| |
| |
//--- End namespace
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
| |
//+------------------------------------------------------------------+
| |
#endif // BASESPARSERSLAN_SRC_QUERY_QUERY_MQH
|