//+------------------------------------------------------------------+ //| Parser.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_PARSER_MQH #define BASESPARSERSLAN_SRC_QUERY_PARSER_MQH //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ #include "AsmDef.mqh" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ namespace TSN { //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ class CSLDomQueryCompiler; class CSLDomQueryVm; //--- typedef void(*CSLQueryFunc)(CSLDomQueryVm*); //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ class CSLDomQueryCompiler { public: //--- Raw uchar m_raw[]; int m_pos; int m_len; int m_offset; //--- Registros (mitad mitad) string m_sreg[TSN_DOMPATH_MAX_SIZE_STR]; int m_sreg_s; DomPathV m_reg[TSN_DOMPATH_MAX_SIZE_REG]; int m_reg_s; protected: //--- Bytecode long m_bytecode[]; int m_bytecode_s; int m_bytecode_r; //--- int m_locked_sreg; //--- Funciones CSLQueryFunc m_funcs[128]; int m_funcs_size; //--- Crea un string int MakeString(int i, const int l); //--- Hashmap intermdio para // que el usuiario guardde sus funciones con un keyu.. y luego se consutla con ese key.. // (bueno con hash) CHashMapFast(string, int) m_hash_func; //--- Del parseo en si // HashMap para mapear los jump CHashMapFast(ulong, int) m_hash_jumps; struct pack(8) PendintHashJump { ulong hash; // hash int bytecode_pos; // Indice del bytecode long mask; // mascara a aplicar al valor int bit_start_mask; }; PendintHashJump m_pendings_hashes[]; int m_pendings_hashes_s; int m_pendings_hashes_r; // Pila de valores tokenizacoin long m_pila_v[ASMPARSER_MAX_VAL_OPS]; uchar m_pila_v_t[ASMPARSER_MAX_VAL_OPS]; int m_pila_v_s; // tamaño actual usado de pila // Siguiente token tokenizacion uint m_pila_ins[ASMPARSER_MAX_VAL_OPS]; int m_pila_ins_t; int m_pila_curr; // curr instruction pila // uchar m_next; // sigueinte token uint m_p_f; // flags del token //--- ENUM_ASM_DOMPATH_PARSER_ERR m_last_err_parse; public: CSLDomQueryCompiler(void); ~CSLDomQueryCompiler(void) {} //--- Correct padding void CorrectPadding(); //--- Load __forceinline void CalcLen() { m_len = ArraySize(m_raw); } inline void Assing(const string& raw); int AssingFile(const string& file_name, const bool comon_flag); bool AutoParseFileByExt(const int reg_type); //--- Lockear vlaores previo a los Run void LockValues(); //--- Save bool SaveCompiled(const string & file_name_out, const bool out_common_flag) const; //--- Normalize void NormalizeUft(); //--- Errores void GetLastErrorLocation(int &col, int &line) const; __forceinline ENUM_ASM_DOMPATH_PARSER_ERR LastErr() const { return m_last_err_parse; } //--- Funciones void SetFunction(const string &func_name, CSLQueryFunc func); //--- Compiladores finales bool CompileAsm(); bool CompileQuery() { return true; } // place holder //--- void Summary(); __forceinline int GetStepIns(const ENUM_DOMPATH_QUERY_INS_TYPE t) const; //--- void ParseErrorInfo(bool w_avanze = false) const; }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CSLDomQueryCompiler::CSLDomQueryCompiler() : m_bytecode_r(256), m_bytecode_s(0), m_pendings_hashes_s(0), m_pendings_hashes_r(16) , m_funcs_size(0), m_sreg_s(0), m_reg_s(0), m_hash_func(64), m_hash_jumps(64) { ArrayResize(m_bytecode, m_bytecode_r, m_bytecode_r); ArrayResize(m_pendings_hashes, m_pendings_hashes_r, m_pendings_hashes_r); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::Summary(void) { Print("---- CSLDomQueryCompiler ----"); Print("-- Bytecode --"); int cur = 0; while(cur < m_bytecode_s) { const ENUM_DOMPATH_QUERY_INS_TYPE t = ENUM_DOMPATH_QUERY_INS_TYPE(m_bytecode[cur] & TSN_DOMPATH_MASK_INS_TYPE); PrintFormat("[%d] %s", cur, EnumToString(t)); cur += GetStepIns(t); } Print("-- Registers --"); Print("Registers str size: ", m_sreg_s); Print("Functions size: ", m_funcs_size); Print("---- end ----"); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ __forceinline int CSLDomQueryCompiler::GetStepIns(const ENUM_DOMPATH_QUERY_INS_TYPE t) const { switch(t) { //--- case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY: case DOMPATH_QUERY_INS_TYPE_ACCESO_KEY_F: return 2; //--- case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX: case DOMPATH_QUERY_INS_TYPE_ACCESO_IDX_F: case DOMPATH_QUERY_INS_TYPE_INICIAR_ITERACION: case DOMPATH_QUERY_INS_TYPE_ITER_ASSING: return 1; //--- case DOMPATH_QUERY_INS_TYPE_EXIST: return 2; //--- case DOMPATH_QUERY_INS_TYPE_SAVE: case DOMPATH_QUERY_INS_TYPE_SAVE_NO_RESET: return 1; //--- 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: case DOMPATH_QUERY_INS_TYPE_M_BIT_NOT: case DOMPATH_QUERY_INS_TYPE_M_UNARY_NOT: case DOMPATH_QUERY_INS_TYPE_COMPARE_EQ: case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR: case DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR_EQ: case DOMPATH_QUERY_INS_TYPE_COMPARE_IS: case DOMPATH_QUERY_INS_TYPE_CALL: return 2; case DOMPATH_QUERY_INS_TYPE_RESERVE: return 1; case DOMPATH_QUERY_INS_TYPE_SLICING: return 2; case DOMPATH_QUERY_INS_TYPE_JUMP: case DOMPATH_QUERY_INS_TYPE_COPY_ALL: case DOMPATH_QUERY_INS_TYPE_APPEND: case DOMPATH_QUERY_INS_TYPE_SALIDA: return 1; default: return 1; } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::LockValues() { // Luego de compilar llamar a esta funcion m_locked_sreg = m_sreg_s; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CSLDomQueryCompiler::AutoParseFileByExt(const int reg_type) { switch(reg_type) { case TSN_DOMPATH_REGTYPE_JSONPB: { return m_bytecode_s > 0; // solo chekeamos si el bytecode cargado es mayor a 0 } case TSN_DOMPATH_REGTYPE_JSONPASM: { CorrectPadding(); return CompileAsm(); } default: { m_last_err_parse = ASM_DOMPATH_PARSER_ERR_INVALID_FILE_EXTENSION; m_pos = 0; return false;; } } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSLDomQueryCompiler::AssingFile(const string &file_name, const bool comon_flag) { const int reg_type = (int)DomPathExtBSPLF_File(file_name); if(reg_type == TSN_DOMPATH_REGTYPE_JSONPB) { // cache ::ResetLastError(); const int fh = FileOpen(file_name, FILE_BIN | FILE_ANSI | (comon_flag ? FILE_COMMON : 0) | FILE_READ); if(fh == INVALID_HANDLE) { return -1; } m_bytecode_s = FileReadInteger(fh); m_bytecode_r = m_bytecode_s; FileReadArray(fh, m_bytecode, 0, m_bytecode_s); m_sreg_s = FileReadInteger(fh); for(int i = 0; i < m_sreg_s; i++) { const int l = FileReadInteger(fh); m_sreg[i] = FileReadString(fh, l); } const int t = FileReadInteger(fh); FileReadArray(fh, m_reg, 0, t); //--- FileClose(fh); //--- return TSN_DOMPATH_REGTYPE_JSONPB; } else { // asm o normal const int l = (int)FileLoad(file_name, m_raw, (comon_flag ? FILE_COMMON : 0)); if(l == -1) return -1; //--- m_len = l; //--- NormalizeUft(); //--- return reg_type; } return 0; // place holder } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CSLDomQueryCompiler::SaveCompiled(const string &file_name_out, const bool out_common_flag) const { //--- const int fh = FileOpen(file_name_out, FILE_WRITE | FILE_BIN | FILE_ANSI | (out_common_flag ? FILE_COMMON : 0)); if(fh == INVALID_HANDLE) { return false; } //--- FileWriteInteger(fh, m_bytecode_s); FileWriteArray(fh, m_bytecode, 0, m_bytecode_s); //--- FileWriteInteger(fh, m_sreg_s); for(int i = 0; i < m_sreg_s; i++) { const int l = StringLen(m_sreg[i]); FileWriteInteger(fh, l); FileWriteString(fh, m_sreg[i], l); } //--- static const int t = TSN_DOMPATH_MAX_SIZE_REG >> 1; FileWriteInteger(fh, t); FileWriteArray(fh, m_reg, 0, t); //--- FileClose(fh); //--- return true; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::SetFunction(const string &func_name, CSLQueryFunc func) { const int idx = m_hash_func.Find(func_name); if(idx == -1) { m_funcs[m_funcs_size] = func; m_hash_func.Add(func_name, m_funcs_size); m_funcs_size++; } else { m_funcs[idx] = func; } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ inline void CSLDomQueryCompiler::Assing(const string& raw) { m_len = StringToCharArray(raw, m_raw); m_offset = 0; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::CorrectPadding() { //--- const int prev = m_len; ArrayResize(m_raw, (m_len += 8)); //--- Rellenamos for(int i = prev; i < m_len; i++) { m_raw[i] = '\n'; } //--- Chekeamos if(m_len > m_bytecode_r) { m_bytecode_r = m_len; ArrayResize(m_bytecode, m_len, m_len); } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::NormalizeUft() { m_offset = 0; //--- if(m_len >= 2) { // UTF16 BE if(m_raw[0] == 0xFF && m_raw[1] == 0xFE) { const int n = (m_len - 2) >> 1; for(int i = 0; i < n; i++) m_raw[i] = m_raw[2 + (i * 2)]; // byte bajo (el char real) m_len = ArrayResize(m_raw, n); } // UTF16 LE else if(m_raw[0] == 0xFE && m_raw[1] == 0xFF) { const int n = (m_len - 2) >> 1; for(int i = 0; i < n; i++) m_raw[i] = m_raw[3 + (i * 2)]; // byte alto (invertido) m_len = ArrayResize(m_raw, n); } } else if(m_len >= 3 && m_raw[0] == 0xEF && m_raw[1] == 0xBB && m_raw[2] == 0xBF) { // UTF-8 BOM m_offset = 3; // simplemente saltear } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSLDomQueryCompiler::MakeString(int i, const int l) { //--- m_sreg[m_sreg_s].Truncate(l); int k = 0; const int e = i + l; //--- for(; i < e; i++) m_sreg[m_sreg_s].SetChar(k++, m_raw[i]); //--- m_sreg_s++; return m_sreg_s - 1; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::GetLastErrorLocation(int &col, int &line) const { col = 1; line = 1; //Print("err:"); //PrintFormat("Val = '%s'", CharArrayToString(m_raw, 0, m_pos)); for(int i = 0; i <= m_pos && i < m_len; i++) { if(m_raw[i] == '\n') { line++; col = 1; } else col++; } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSLDomQueryCompiler::ParseErrorInfo(bool w_avanze) const { if(m_last_err_parse == ASM_DOMPATH_PARSER_ERR_NOT) return; //--- int col, line; GetLastErrorLocation(col, line); string err = ""; //--- switch(m_last_err_parse) { case ASM_DOMPATH_PARSER_ERR_MALFORMERD_ASM: err = "ASM mal formado: se encontro un token que no era valido en este punto"; break; case ASM_DOMPATH_PARSER_ERR_INVALID_INSTRUCTION: err = "Instruccion invalida: el nombre de instruccion (INS_*) no existe"; break; case ASM_DOMPATH_PARSER_ERR_INVALID_TOKEN: err = "Token invalido: caracter inesperado, no coincide con ningun token conocido"; break; case ASM_DOMPATH_PARSER_ERR_JUMP_NOT_CLOSED: err = "Etiqueta de salto (@Alias:) sin cerrar antes del final del archivo"; break; case ASM_DOMPATH_PARSER_ERR_INVALID_CASE_INS: err = "Instruccion reconocida pero sin manejo implementado en el compilador (case invalido)"; break; case ASM_DOMPATH_PARSER_ERR_STRING_NOT_CLOSED: err = "Cadena (string) sin comilla de cierre antes del final del archivo"; break; case ASM_DOMPATH_PARSER_ERR_INVALID_JUMP_KEY: err = "Salto a una etiqueta que nunca fue declarada (@Alias: inexistente)"; break; case ASM_DOMPATH_PARSER_ERR_STR_HASH_NOT_CLOSED: err = "Hash de salto (' o *) sin caracter de cierre antes del final del archivo"; break; case ASM_DOMPATH_PARSER_ERR_MALFORMERD_ASM_CTX_GEN: err = "ASM mal formado dentro del contexto de generacion (secuencia de tokens invalida para esta instruccion)"; break; case ASM_DOMPATH_PARSER_ERR_FUNCTION_NOT_EXIST: err = "La funcion invocada (CALL) no fue registrada previamente con SetFunction"; break; case ASM_DOMPATH_PARSER_ERR_COMENTARIO_NO_CERRO_Y_AUN_QUEDA_ALGO: err = "El comentario no cerro correctamente y aun quedaba contenido pendiente de parsear"; break; case ASM_DOMPATH_PARSER_ERR_INVALID_FILE_EXTENSION: err = "Tipo de extension de archivo invalida"; break; default: err = "Error desconocido"; break; } //--- PrintFormat("[DomPath ASM] Error (linea %d, columna %d):\n'%s'", line, col, err); //--- if(w_avanze) { Print("Avanze: "); Print("--------"); Print(CharArrayToString(m_raw, 0, m_pos)); Print("--------"); } } } //+------------------------------------------------------------------+ #endif // BASESPARSERSLAN_SRC_QUERY_PARSER_MQH //+------------------------------------------------------------------+