2026-07-23 22:03:03 -05:00 | | | //+------------------------------------------------------------------+
|
2026-07-19 22:56:57 -05:00 | | | //| Query.mqh |
|
2026-07-22 15:26:43 -05:00 | | | //| Copyright 2026, Nique. |
|
2026-07-19 22:56:57 -05:00 | | | //| https://www.mql5.com |
|
| | | //+------------------------------------------------------------------+
|
2026-07-22 15:26:43 -05:00 | | | #property copyright "Copyright 2026, Nique."
|
2026-07-19 22:56:57 -05:00 | | | #property link "https://www.mql5.com"
|
| | | #property strict
|
| | |
|
2026-07-23 22:03:03 -05:00 | | | #ifndef BASESPARSERSLAN_SRC_QUERY_QUERY_MQH
|
| | | #define BASESPARSERSLAN_SRC_QUERY_QUERY_MQH
|
| | |
|
2026-07-19 22:56:57 -05:00 | | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
2026-07-24 14:20:05 -05:00 | | | #include "Asm.mqh"
|
2026-07-19 22:56:57 -05:00 | | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
| | | namespace TSN
|
| | | {
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
2026-10-27 10:44:45 -05:00 | | | class CSLDomQueryVm : public CTSNSLDomQueryCompiler
|
2026-07-19 22:56:57 -05:00 | | | {
|
| | | private:
|
2026-07-20 22:44:15 -05:00 | | | //--- Iteracion
|
2026-07-22 15:26:43 -05:00 | | | //- ambos (que tipos se aceptan)
|
| | | uchar m_stack_it_types[TSN_DOMPATH_MAX_DEPTH_ITER];
|
2026-07-22 16:22:12 -05:00 | | |
|
2026-07-19 22:56:57 -05:00 | | | //- iteracion de obj
|
2026-07-20 22:44:15 -05:00 | | | CHashMapFastIterator(string, CDomNodeBase*) m_stack_it_obj[TSN_DOMPATH_MAX_DEPTH_ITER];
|
2026-07-22 16:22:12 -05:00 | | |
|
2026-07-19 22:56:57 -05:00 | | | //- iteracion de array
|
2026-07-22 16:22:12 -05:00 | | | 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)
|
2026-07-22 15:26:43 -05:00 | | | int m_stack_it_count[TSN_DOMPATH_MAX_DEPTH_ITER]; // numero de elementos restantes.
|
2026-07-22 16:22:12 -05:00 | | | int m_stack_it_ix[TSN_DOMPATH_MAX_DEPTH_ITER]; // indice en m_ctx.m_nodes
|
| | |
|
| | | //- indice de la iteracion actual
|
2026-07-19 22:56:57 -05:00 | | | int m_stack_it_curr;
|
| | |
|
2026-07-22 15:26:43 -05:00 | | | //--- Registros de nodes
|
2026-07-23 22:12:19 -05:00 | | | CDomNodeBase* m_dnodes[TSN_DOMPATH_MAX_SIZE_DNODES];
|
2026-07-21 08:53:15 -05:00 | | | int m_dnodes_size;
|
2026-07-20 22:44:15 -05:00 | | |
|
| | | //--- Actual
|
| | | ulong m_current_hash;
|
2026-07-19 22:56:57 -05:00 | | | CDomNodeBase* m_curr;
|
| | |
|
2026-07-22 16:22:12 -05:00 | | | //--- Instrution pointer
|
2026-07-20 22:44:15 -05:00 | | | int m_ip;
|
| | |
|
2026-07-24 21:56:07 -05:00 | | | //---
|
| | | CDomNodeBase* m_base_node;
|
| | |
|
2026-07-22 16:22:12 -05:00 | | | public:
|
| | | //--- Call frame actual
|
| | | int m_num_args;
|
2026-07-24 14:20:05 -05:00 | | | int m_reg_start_params;
|
2026-07-22 16:22:12 -05:00 | | |
|
2026-07-24 21:56:07 -05:00 | | | //--- Objeto actual
|
| | | int m_el_s;
|
| | | int m_el_r;
|
| | |
|
2026-07-19 22:56:57 -05:00 | | | public:
|
2026-07-23 22:03:03 -05:00 | | | CSLDomQueryVm(void) {}
|
| | | ~CSLDomQueryVm(void) {}
|
2026-07-19 22:56:57 -05:00 | | |
|
2026-07-24 14:20:05 -05:00 | | | //--- Metodo base
|
2026-07-22 15:26:43 -05:00 | | | bool Run(CDomNodeBase* &elemts[]);
|
2026-07-24 14:20:05 -05:00 | | |
|
2026-07-24 21:56:07 -05:00 | | | //---
|
| | | void BaseNode(CDomNodeBase* base) { m_base_node = base; }
|
| | | CDomNodeBase* BaseNode() { return m_base_node; }
|
| | |
|
2026-07-24 14:20:05 -05:00 | | | //--- 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);
|
2026-07-19 22:56:57 -05:00 | | | };
|
| | |
|
2026-07-24 14:20:05 -05:00 | | | //+------------------------------------------------------------------+
|
| | | //| 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)
|
| | | {
|
2026-10-01 08:24:58 -05:00 | | | //Print("new integer: ", v);
|
2026-07-24 14:20:05 -05:00 | | | 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++;
|
| | | }
|
| | |
|
2026-07-19 22:56:57 -05:00 | | | //+------------------------------------------------------------------+
|
2026-07-22 15:26:43 -05:00 | | | //| Bloque math |
|
2026-07-19 22:56:57 -05:00 | | | //+------------------------------------------------------------------+
|
2026-07-22 15:26:43 -05:00 | | | #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;\
|
| | | }
|
2026-07-19 22:56:57 -05:00 | | |
|
2026-07-20 22:44:15 -05:00 | | |
|
2026-07-22 15:26:43 -05:00 | | | //----- 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;\
|
| | | }\
|
2026-07-20 22:44:15 -05:00 | | | default:\
|
2026-07-22 15:26:43 -05:00 | | | m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
|
2026-07-20 22:44:15 -05:00 | | | break;\
|
2026-07-22 15:26:43 -05:00 | | | }
|
2026-07-20 22:44:15 -05:00 | | |
|
| | |
|
2026-07-22 15:26:43 -05:00 | | | //-------------------
|
| | | #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)\
|
| | | {\
|
2026-07-23 10:54:27 -05:00 | | | m_ip = int(l2 >> TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR);\
|
2026-07-22 15:26:43 -05:00 | | | }\
|
| | | 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;\
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | |
|
2026-07-22 15:26:43 -05:00 | | |
|
| | | // "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) \
|
2026-07-20 22:44:15 -05:00 | | | switch(B.tt) \
|
| | | { \
|
| | | case DOMPATHV_TYPE_BOL: \
|
2026-07-22 15:26:43 -05:00 | | | res = (B.v.bv OP (C.tt == DOMPATHV_TYPE_FLT ? (bool)C.v.dv : (bool)C.v.iv)); \
|
2026-07-20 22:44:15 -05:00 | | | 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: \
|
2026-07-22 15:26:43 -05:00 | | | res = (B.v.dv OP (C.tt != DOMPATHV_TYPE_FLT ? (double)C.v.iv : C.v.dv)); \
|
2026-07-20 22:44:15 -05:00 | | | break; \
|
| | | case DOMPATHV_TYPE_STR: \
|
| | | {\
|
| | | if(C.tt!=DOMPATHV_TYPE_STR)\
|
| | | break; \
|
2026-07-22 15:26:43 -05:00 | | | res = m_sreg[B.v.ix] OP m_sreg[C.v.ix]; \
|
2026-07-20 22:44:15 -05:00 | | | break; \
|
| | | } \
|
| | | default: \
|
| | | break; \
|
| | | }
|
| | |
|
| | | //---
|
| | | #define TSN_DOMPATH_DEFINE_BOOL_OP(OP) \
|
| | | bool res=false;\
|
| | | const long l = m_bytecode[m_ip];\
|
2026-07-22 15:26:43 -05:00 | | | 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) \
|
2026-07-20 22:44:15 -05:00 | | | m_ip++;\
|
2026-07-22 15:26:43 -05:00 | | | 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]);
|
2026-07-20 22:44:15 -05:00 | | |
|
| | |
|
| | | //+------------------------------------------------------------------+
|
| | | //| |
|
| | | //+------------------------------------------------------------------+
|
2026-07-23 22:03:03 -05:00 | | | bool CSLDomQueryVm::Run(CDomNodeBase* &elemts[])
|
2026-07-19 22:56:57 -05:00 | | | {
|
| | | //---
|
2026-07-20 22:44:15 -05:00 | | | m_ip = 0;
|
2026-07-24 21:56:07 -05:00 | | | m_el_s = 0;
|
| | | m_el_r = ArrayResize(elemts, 8, 8);
|
2026-07-22 15:26:43 -05:00 | | | m_stack_it_curr = -1;
|
2026-07-23 22:12:19 -05:00 | | |
|
| | | //--- Reinicio
|
| | | m_sreg_s = m_locked_sreg; // Empieza desde ahi
|
| | | m_dnodes_size = 0; // Tambien de 0
|
2026-07-24 21:56:07 -05:00 | | | m_curr = m_base_node;
|
| | | // inicia en mitad por convencion para los dinamicos...
|
| | | m_reg_s = TSN_DOMPATH_MAX_SIZE_REG >> 1;
|
2026-07-19 22:56:57 -05:00 | | |
|
| | | //---
|
2026-07-22 15:26:43 -05:00 | | | while(true)
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | switch(uchar(m_bytecode[m_ip]&TSN_DOMPATH_MASK_INS_TYPE))
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | //--- Acceso
|
| | | // Acceso normal en iteracion
|
2026-07-19 22:56:57 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | // [8bit=Type][28bit=a donde saltar instucino ip]
|
| | | // [64hash=completo]
|
2026-07-20 22:44:15 -05:00 | | | // accceso directo por hash 64
|
| | | m_curr = m_curr.Get((ulong)m_bytecode[m_ip + 1]);
|
| | | if(m_curr == NULL)
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
2026-07-22 15:26:43 -05:00 | | | // no fallo eotnces slatoams dos
|
| | | m_ip += 2; // [curr][hash] [aqui]
|
2026-07-20 22:44:15 -05:00 | | | 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)
|
2026-07-22 15:26:43 -05:00 | | | return false;
|
| | | // no fallo eotnces slatoams dos
|
| | | m_ip += 2; // [curr][hash] [aqui]
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | // [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
|
2026-07-20 22:44:15 -05:00 | | | if(m_curr == NULL)
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_INS_ACCESO_INDEX_JUMP_BIT_S);
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
2026-07-22 15:26:43 -05:00 | | | m_ip++; // todo bien salta al siguiente
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-22 15:26:43 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX_F:
|
2026-07-20 22:44:15 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | // [8bit=type][28bit=index]
|
| | | m_curr = m_curr.AtSafe(int(m_bytecode[m_ip++] >> TSN_DOMPATH_BIT_INS_ETYPE)); // Acceso
|
2026-07-20 22:44:15 -05:00 | | | if(m_curr == NULL)
|
2026-07-22 15:26:43 -05:00 | | | return false; // aqui seria finalizar directo..
|
| | | m_ip++;
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
| | |
|
| | | //--- Iniciar iteracion
|
2026-07-19 22:56:57 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_INICIAR_ITERACION:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | // No reuiqre mas solo type.. [8bit][8bit=qeu aceptamos, 0xff si aceptos de todo]
|
2026-07-22 16:22:12 -05:00 | | | //---
|
2026-07-20 22:44:15 -05:00 | | | m_stack_it_curr++;
|
2026-07-22 16:22:12 -05:00 | | | m_stack_it_types[m_stack_it_curr] = uchar(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
|
| | |
|
| | | //---
|
2026-07-19 22:56:57 -05:00 | | | if(m_curr.m_type == TSN_SBL_BASE_TYPE_OBJ)
|
| | | {
|
| | | m_stack_it_obj[m_stack_it_curr] = m_curr.BenginIteration();
|
2026-07-22 15:26:43 -05:00 | | | m_stack_it_count[m_stack_it_curr] = -1;
|
2026-07-24 21:56:07 -05:00 | | | m_stack_it_k[m_stack_it_curr] = 0;
|
2026-07-19 22:56:57 -05:00 | | | }
|
| | | else
|
| | | {
|
2026-07-22 16:22:12 -05:00 | | | 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
|
2026-07-19 22:56:57 -05:00 | | | }
|
2026-07-24 21:56:07 -05:00 | | |
|
| | | //---
|
| | | m_ip++;
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_ITER_ASSING:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | // [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
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-24 21:56:07 -05:00 | | | //---
|
| | | if(m_stack_it_k[m_stack_it_curr] > 0)
|
| | | m_stack_it_obj[m_stack_it_curr].Next();
|
| | |
|
| | | //---
|
2026-07-19 22:56:57 -05:00 | | | if(m_stack_it_obj[m_stack_it_curr].IsValid())
|
| | | {
|
2026-07-24 21:56:07 -05:00 | | | //--- En caso sea 0 no.. venimos.. aun tomamos los valores y recien ahi..
|
2026-07-20 22:44:15 -05:00 | | | m_current_hash = m_stack_it_obj[m_stack_it_curr].Hash();
|
2026-07-19 22:56:57 -05:00 | | | m_curr = m_stack_it_obj[m_stack_it_curr].Val();
|
2026-07-24 21:56:07 -05:00 | | | //Print(m_stack_it_obj[m_stack_it_curr].Key());
|
| | | m_stack_it_k[m_stack_it_curr]++;
|
2026-07-19 22:56:57 -05:00 | | | }
|
| | | else // SI no es valido
|
| | | {
|
2026-07-22 16:22:12 -05:00 | | | m_stack_it_curr--;
|
2026-07-22 15:26:43 -05:00 | | | // Saltamos a donde se diga una vez que termine la iteracion
|
2026-07-20 22:44:15 -05:00 | | | m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
|
2026-07-22 15:26:43 -05:00 | | | break; // de una salimos de aqui
|
2026-07-19 22:56:57 -05:00 | | | }
|
| | | }
|
| | | else
|
| | | {
|
2026-07-22 16:22:12 -05:00 | | | if(m_stack_it_k[m_stack_it_curr] < m_stack_it_count[m_stack_it_curr])
|
| | | {
|
2026-07-24 21:56:07 -05:00 | | | 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]++];
|
2026-07-22 16:22:12 -05:00 | | | }
|
| | | 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
|
| | | }
|
2026-07-19 22:56:57 -05:00 | | | }
|
2026-07-22 15:26:43 -05:00 | | |
|
| | | //--- Ahora verificamos tipo
|
2026-07-22 16:22:12 -05:00 | | | const uchar t = m_stack_it_types[m_stack_it_curr];
|
2026-07-22 15:26:43 -05:00 | | | 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++;
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | //---
|
| | | case DOMPATH_QUERY_INS_TYPE_EXIST:
|
2026-07-20 07:27:42 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | // 2 slots
|
2026-07-22 16:22:12 -05:00 | | | // 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]
|
2026-07-20 07:27:42 -05:00 | | | break;
|
| | | }
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | //--- save basico para nativos
|
| | | case DOMPATH_QUERY_INS_TYPE_SAVE:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | // [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)
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-10-08 21:53:00 -05:00 | | | case TSN_SBL_BASE_TYPE_ARR:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-10-08 21:53:00 -05:00 | | | m_reg[k].tt = DOMPATHV_TYPE_ARR;
|
2026-07-21 08:53:15 -05:00 | | | m_reg[k].v.ix = m_dnodes_size;
|
| | | m_dnodes[m_dnodes_size++] = m_curr;
|
| | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-10-08 21:53:00 -05:00 | | | case TSN_SBL_BASE_TYPE_OBJ:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-10-08 21:53:00 -05:00 | | | m_reg[k].tt = DOMPATHV_TYPE_OBJ;
|
2026-07-21 08:53:15 -05:00 | | | m_reg[k].v.ix = m_dnodes_size;
|
| | | m_dnodes[m_dnodes_size++] = m_curr;
|
2026-10-01 08:24:58 -05:00 | | | 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;
|
2026-07-21 08:53:15 -05:00 | | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-20 22:44:15 -05:00 | | | case TSN_SBL_BASE_TYPE_INT:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | m_reg[k].v.iv = m_curr.m_v.iv;
|
| | | m_reg[k].tt = DOMPATHV_TYPE_INT;
|
2026-07-19 22:56:57 -05:00 | | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-20 22:44:15 -05:00 | | | case TSN_SBL_BASE_TYPE_FLT:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | m_reg[k].v.dv = m_curr.m_v.dv;
|
| | | m_reg[k].tt = DOMPATHV_TYPE_FLT;
|
| | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-20 22:44:15 -05:00 | | | case TSN_SBL_BASE_TYPE_BOL:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | m_reg[k].v.bv = m_curr.m_v.bv;
|
| | | m_reg[k].tt = DOMPATHV_TYPE_BOL;
|
| | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-20 22:44:15 -05:00 | | | case TSN_SBL_BASE_TYPE_STR:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | 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;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-22 15:26:43 -05:00 | | | 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
|
2026-10-01 08:24:58 -05:00 | | | m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START) - 1;
|
2026-07-22 15:26:43 -05:00 | | | break;
|
| | | }
|
| | | }
|
| | |
|
2026-10-01 08:24:58 -05:00 | | | //---
|
| | | m_ip++;
|
| | |
|
2026-07-22 15:26:43 -05:00 | | | //---
|
| | | // 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)
|
| | | {
|
2026-10-08 21:53:00 -05:00 | | | case TSN_SBL_BASE_TYPE_ARR:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-10-08 21:53:00 -05:00 | | | m_reg[k].tt = DOMPATHV_TYPE_ARR;
|
2026-07-22 15:26:43 -05:00 | | | m_reg[k].v.ix = m_dnodes_size;
|
| | | m_dnodes[m_dnodes_size++] = m_curr;
|
| | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-10-08 21:53:00 -05:00 | | | case TSN_SBL_BASE_TYPE_OBJ:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-10-08 21:53:00 -05:00 | | | m_reg[k].tt = DOMPATHV_TYPE_OBJ;
|
2026-07-22 15:26:43 -05:00 | | | m_reg[k].v.ix = m_dnodes_size;
|
| | | m_dnodes[m_dnodes_size++] = m_curr;
|
2026-10-01 08:24:58 -05:00 | | | 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;
|
2026-07-22 15:26:43 -05:00 | | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-22 15:26:43 -05:00 | | | case TSN_SBL_BASE_TYPE_INT:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | m_reg[k].v.iv = m_curr.m_v.iv;
|
| | | m_reg[k].tt = DOMPATHV_TYPE_INT;
|
| | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-22 15:26:43 -05:00 | | | case TSN_SBL_BASE_TYPE_FLT:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | m_reg[k].v.dv = m_curr.m_v.dv;
|
| | | m_reg[k].tt = DOMPATHV_TYPE_FLT;
|
| | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-22 15:26:43 -05:00 | | | case TSN_SBL_BASE_TYPE_BOL:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | m_reg[k].v.bv = m_curr.m_v.bv;
|
2026-07-20 22:44:15 -05:00 | | | m_reg[k].tt = DOMPATHV_TYPE_BOL;
|
2026-07-22 15:26:43 -05:00 | | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-22 15:26:43 -05:00 | | | case TSN_SBL_BASE_TYPE_STR:
|
2026-07-23 10:54:27 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | m_reg[k].tt = TSN_SBL_BASE_TYPE_STR;
|
2026-07-20 22:44:15 -05:00 | | | m_reg[k].v.ix = m_sreg_s;
|
2026-07-22 15:26:43 -05:00 | | | m_sreg[m_sreg_s++] = m_curr.m_ctx.m_string_stack[m_curr.m_v.ix];
|
2026-07-19 22:56:57 -05:00 | | | break;
|
2026-07-23 10:54:27 -05:00 | | | }
|
2026-07-19 22:56:57 -05:00 | | | default:
|
2026-07-20 22:44:15 -05:00 | | | {
|
2026-07-21 08:53:15 -05:00 | | | // 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
|
2026-07-20 22:44:15 -05:00 | | | // Aqui un jump a direccion especificada
|
2026-10-01 08:24:58 -05:00 | | | m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START) - 1;
|
2026-07-19 22:56:57 -05:00 | | | break;
|
2026-07-20 22:44:15 -05:00 | | | }
|
2026-07-19 22:56:57 -05:00 | | | }
|
2026-10-01 08:24:58 -05:00 | | |
|
2026-10-08 21:53:00 -05:00 | | | //---
|
2026-10-01 08:24:58 -05:00 | | | m_ip++;
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | //--- math
|
| | | // math entero usa 2 slots.. para sus intrucciones
|
2026-07-22 15:26:43 -05:00 | | | // [type][28][28] | [28] [28]
|
| | | // 8type 28b 28c 28a 28jump
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_M_MUL:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_ALL(*)
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_M_RES:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_ALL(-)
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_M_DIV:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_ALL( /)
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_M_SUM:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_SUM
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_M_MOD:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_INTEGER( %)
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_M_BIT_OR:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_INTEGER( |)
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_M_BIT_AND:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_INTEGER(&)
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_M_BIT_XOR:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_INTEGER(^)
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_IZQ:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_INTEGER( <<)
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_DRC:
|
| | | {
|
2026-07-22 15:26:43 -05:00 | | | TSN_DOMPATH_DO_MATH_TYPED_INTEGER( >>)
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
2026-07-22 16:22:12 -05:00 | | | 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..
|
2026-07-27 17:31:06 -05:00 | | | m_ip = int(l >> TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR); // fallo
|
2026-07-22 16:22:12 -05:00 | | | break;
|
| | | }
|
| | | }
|
| | | break;
|
| | | }
|
2026-07-19 22:56:57 -05:00 | | |
|
2026-07-20 22:44:15 -05:00 | | | //--- Operaciones de compracion
|
| | | // [type][28][28] | [2][28][1]
|
| | | //--- Cmp (comparaciones..)
|
| | | case DOMPATH_QUERY_INS_TYPE_COMPARE_EQ:
|
| | | {
|
| | | TSN_DOMPATH_DEFINE_BOOL_OP( ==)
|
2026-07-24 21:56:07 -05:00 | | | //Print("Hola: ", res);
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | TSN_DOMPATH_DEFINE_BOOL_OP( <)
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR_EQ:
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-20 22:44:15 -05:00 | | | TSN_DOMPATH_DEFINE_BOOL_OP( <=)
|
| | | break;
|
| | | }
|
| | | case DOMPATH_QUERY_INS_TYPE_COMPARE_IS:
|
| | | {
|
2026-07-22 16:22:12 -05:00 | | | //--- [8bytes][KIndex=28][28=Jump] | [1 bit = resultado esperado]
|
2026-07-20 22:44:15 -05:00 | | | bool res = false;
|
| | | const int k = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE) & TSN_DOMPATH_INS_MASK_INDEX_REG;
|
2026-07-24 14:20:05 -05:00 | | |
|
2026-07-24 21:56:07 -05:00 | | | switch(m_reg[k].tt)
|
2026-07-19 22:56:57 -05:00 | | | {
|
2026-07-24 21:56:07 -05:00 | | | case DOMPATHV_TYPE_BOL:
|
| | | res = m_reg[k].v.bv;
|
| | | break;
|
| | | case DOMPATHV_TYPE_INT:
|
2026-07-20 22:44:15 -05:00 | | | res = m_reg[k].v.iv != 0;
|
| | | break;
|
2026-07-24 21:56:07 -05:00 | | | case DOMPATHV_TYPE_FLT:
|
2026-07-20 22:44:15 -05:00 | | | res = m_reg[k].v.dv != 0;
|
| | | break;
|
2026-07-24 21:56:07 -05:00 | | | case DOMPATHV_TYPE_STR:
|
2026-07-20 22:44:15 -05:00 | | | res = m_sreg[m_reg[k].v.ix].Length() != 0;
|
| | | break;
|
| | | default:
|
| | | break;
|
2026-07-19 22:56:57 -05:00 | | | }
|
2026-07-20 22:44:15 -05:00 | | |
|
2026-07-24 21:56:07 -05:00 | | | //--
|
| | | //Print("is: ", res, " k: ", k);
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | //---
|
| | | 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
|
2026-07-19 22:56:57 -05:00 | | | break;
|
| | | }
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | //---
|
| | | case DOMPATH_QUERY_INS_TYPE_CALL:
|
| | | {
|
2026-07-24 14:20:05 -05:00 | | | // [8type][28=direecion donde empieza todo][28 numero de argumentos][Indice de la funcion]
|
2026-07-20 22:44:15 -05:00 | | | // [indice de funcion] (slot completo)
|
2026-07-24 14:20:05 -05:00 | | | 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
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | m_num_args = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_BIT_START_NARGS);
|
| | | m_ip++;
|
2026-07-24 14:20:05 -05:00 | | |
|
| | | //---
|
2026-07-24 21:56:07 -05:00 | | | // Empiza aqui todo... el resultado
|
| | | const int lock = m_reg_start_params + m_num_args;
|
| | |
|
| | | //---
|
| | | m_reg_s = lock + 1;
|
| | |
|
| | | //---
|
2026-07-20 22:44:15 -05:00 | | | m_funcs[m_bytecode[m_ip]](&this); // llamamos
|
2026-07-24 21:56:07 -05:00 | | | //Print("Num:" , (m_reg_s - lock) - 1);
|
2026-07-24 14:20:05 -05:00 | | |
|
| | | //---
|
| | | m_reg[lock].tt = DOMPATHV_TYPE_INT;
|
2026-07-24 21:56:07 -05:00 | | | m_reg[lock].v.iv = (m_reg_s - lock) - 1; // 1 dado qeu empiza...
|
2026-07-24 14:20:05 -05:00 | | |
|
2026-07-20 22:44:15 -05:00 | | | // ahora ya se sape que la funcion escrbiio un valor en dicho registro
|
| | | m_ip++; // Siguiente insturccion
|
| | | break;
|
| | | }
|
2026-07-19 22:56:57 -05:00 | | |
|
2026-07-22 15:26:43 -05:00 | | | //---
|
| | | case DOMPATH_QUERY_INS_TYPE_RESERVE:
|
2026-07-20 22:44:15 -05:00 | | | {
|
2026-07-22 15:26:43 -05:00 | | | // 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++;
|
2026-07-20 22:44:15 -05:00 | | | m_ip++;
|
2026-07-19 22:56:57 -05:00 | | | break;
|
2026-07-20 22:44:15 -05:00 | | | }
|
2026-07-19 22:56:57 -05:00 | | |
|
2026-07-22 15:26:43 -05:00 | | | //--- 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);
|
2026-07-24 21:56:07 -05:00 | | | m_el_s += m_curr.PySlicing(elemts, m_el_s, s, e, p);
|
2026-07-22 15:26:43 -05:00 | | | 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;
|
| | | }
|
| | |
|
2026-07-22 16:22:12 -05:00 | | | //---
|
| | | case DOMPATH_QUERY_INS_TYPE_COPY_ALL:
|
| | | {
|
2026-07-24 21:56:07 -05:00 | | | const int t = m_curr.CopyTo(elemts, m_el_s);
|
| | | if(t == -1)
|
2026-07-22 16:22:12 -05:00 | | | {
|
| | | m_ip = int(m_bytecode[m_ip] >> TSN_DOMPATH_BIT_INS_ETYPE);
|
| | | break;
|
| | | }
|
2026-07-24 21:56:07 -05:00 | | | m_el_s += t;
|
| | | m_ip++;
|
2026-07-22 16:22:12 -05:00 | | | break;
|
| | | }
|
| | |
|
2026-07-20 22:44:15 -05:00 | | | //--- Finaes
|
| | | case DOMPATH_QUERY_INS_TYPE_APPEND:
|
| | | {
|
2026-07-24 21:56:07 -05:00 | | | if(m_el_s + 1 >= m_el_r)
|
2026-07-22 15:26:43 -05:00 | | | {
|
2026-07-24 21:56:07 -05:00 | | | m_el_r += (m_el_s << 1) + 8;
|
| | | ArrayResize(elemts, m_el_r, m_el_r);
|
2026-07-22 15:26:43 -05:00 | | | }
|
2026-07-24 21:56:07 -05:00 | | | elemts[m_el_s++] = m_curr; // Actual
|
| | | m_ip++;
|
2026-07-20 22:44:15 -05:00 | | | break;
|
| | | }
|
2026-07-23 10:54:27 -05:00 | | |
|
2026-07-20 22:44:15 -05:00 | | | case DOMPATH_QUERY_INS_TYPE_SALIDA:
|
| | | return true;
|
2026-07-22 15:26:43 -05:00 | | |
|
2026-07-20 22:44:15 -05:00 | | | default:
|
| | | return false;
|
| | | }
|
2026-07-19 22:56:57 -05:00 | | | }
|
2026-07-23 10:54:27 -05:00 | | |
|
| | | //---
|
2026-07-19 22:56:57 -05:00 | | | }
|
| | |
|
2026-07-23 10:54:27 -05:00 | | |
|
2026-07-22 15:26:43 -05:00 | | | //--- End namespace
|
2026-07-19 22:56:57 -05:00 | | | }
|
2026-07-23 10:54:27 -05:00 | | |
|
2026-07-19 22:56:57 -05:00 | | | //+------------------------------------------------------------------+
|
| | |
|
| | | //+------------------------------------------------------------------+
|
2026-07-23 22:12:19 -05:00 | | | #endif // BASESPARSERSLAN_SRC_QUERY_QUERY_MQH
|