BasesParserSLan/Src/Query/AsmDef.mqh

//+------------------------------------------------------------------+
//|                                                       AsmDef.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_ASMDEF_MQH
#define BASESPARSERSLAN_SRC_QUERY_ASMDEF_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//--- Neceistamos la tabla hex
#ifndef TSNTABLE_USE_HEX_TABLE
#define TSNTABLE_USE_HEX_TABLE
#endif // TSNTABLE_USE_HEX_TABLE

//--- Neceistamos la tabla de hexponentes
#ifndef TSNTABLE_USE_POWEXP_TABLE
#define TSNTABLE_USE_POWEXP_TABLE
#endif // TSNTABLE_USE_POWEXP_TABLE

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "Def.mqh"
#include <TSN\\Tables\\Main.mqh>
#include <TSN\\Tables\\Swar.mqh>

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{


//----
#define ASMPARSER_MAX_VAL_OPS (5)

//---
struct OpCodeTable
 {
  const int          len;
  const uint         ops[ASMPARSER_MAX_VAL_OPS];
  const long         mask;
  const int          bit_start;
 };


//---
#define ASM_PARSER_TOKF_REGISTER 1
#define ASM_PARSER_TOKF_NUMBER   2
#define ASM_PARSER_TOKF_TRUE     4
#define ASM_PARSER_TOKF_FALSE    8
#define ASM_PARSER_TOKF_STR      16
#define ASM_PARSER_TOKF_S_STR    32
#define ASM_PARSER_TOKF_EQ       64
#define ASM_PARSER_TOKF_STR_HASH        128
#define ASM_PARSER_TOKF_PARSE_KEY_HASH  256
#define ASM_PARSER_TOKF_COMMENT         512
#define ASM_PARSER_TOKF_PARSE_INS       1024
#define ASM_PARSER_TOKF_PARSE_END       2048
#define ASM_PARSER_TOKF_PARSE_JUMP_S    4096


//---
#define ASM_PARSER_ALL_VALID_NORMAL (ASM_PARSER_TOKF_PARSE_JUMP_S|ASM_PARSER_TOKF_REGISTER|ASM_PARSER_TOKF_COMMENT|ASM_PARSER_TOKF_PARSE_INS)

//---
#define ASM_PARSER_TOK_ALLSTR (ASM_PARSER_TOKF_S_STR | ASM_PARSER_TOKF_STR)

/*
  ASM_PARSER_TOK_MAKE_REG,  // hacer un regriso luedo inicarlo...
  ASM_PARSER_TOK_PARSE_INS, // instruccion #MUL
  ASM_PARSER_TOK_PARSE_END, // Delegar a especifica
  ASM_PARSER_TOK_PARSE_JUMP_S, // Jump start
  ASM_PARSER_TOK_INVALID
*/

const  OpCodeTable g_dompath_op_codes[] =
 {
//--- base
   {
    3,
     {ASM_PARSER_TOKF_STR_HASH, ASM_PARSER_TOKF_PARSE_KEY_HASH, DOMPATH_QUERY_INS_TYPE_ACCESO_KEY},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_ETYPE, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_ETYPE, // jump: slot0 bit8, 28b
   },
   {2, {ASM_PARSER_TOKF_PARSE_KEY_HASH, DOMPATH_QUERY_INS_TYPE_ACCESO_KEY_F}}, // sin jump (F = fatal, return false)
   {
    3,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_ACCESO_IDX},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_INS_ACCESO_INDEX_JUMP_BIT_S, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_INS_ACCESO_INDEX_JUMP_BIT_S, // jump: slot0 bit36, 28b
   },
   {2, {ASM_PARSER_TOKF_NUMBER, DOMPATH_QUERY_INS_TYPE_ACCESO_IDX_F}}, // sin jump (F = fatal, return false)
   {2, {ASM_PARSER_TOKF_NUMBER, DOMPATH_QUERY_INS_TYPE_INICIAR_ITERACION}}, // sin jump
   {
    2,
     {ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_ITER_ASSING},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_ETYPE, TSN_DOMPATH_INS_ITER_MASK_JUMP), TSN_DOMPATH_BIT_INS_ETYPE, // jump: slot0 bit8, 28b
   },
   {
    2,
     {ASM_PARSER_TOKF_STR_HASH, ASM_PARSER_TOKF_PARSE_KEY_HASH, DOMPATH_QUERY_INS_TYPE_EXIST},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_ETYPE, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_ETYPE, // jump: slot0 bit8, 28b
   },
   {
    3,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_SAVE},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START, // jump: slot0 bit36, 28b
   },
   {
    3,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_SAVE_NO_RESET},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_SAVEPTR_JUMP_BIT_START, // jump: slot0 bit36, 28b
   },

//--- math all base (jump de error vive en el SLOT 2, no en el slot 0: [type|B|C][A|jump])
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_MUL},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_RES},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_DIV},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_SUM},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_MOD},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_BIT_OR},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_BIT_AND},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_BIT_XOR},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_IZQ},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_M_BIT_DEZ_DRC},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_MATHERR, // jump: slot1 bit28, 28b
   },

//-- unary (jump de error vive en el SLOT 0: [type|B|jump][A])
   {
    4,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, ASM_PARSER_TOKF_NUMBER, DOMPATH_QUERY_INS_TYPE_M_BIT_NOT},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR, // jump: slot0 bit36, 28b
   },
   {
    4,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, ASM_PARSER_TOKF_NUMBER, DOMPATH_QUERY_INS_TYPE_M_UNARY_NOT},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_UNARY_MATHERR, // jump: slot0 bit36, 28b
   },

//-- cmp (jump vive en el SLOT 2: [type|B|C][expected|jump], se lee tras m_ip++)
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_COMPARE_EQ},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_CMPFALSE, TSN_DOMPATH_BIT_INS_JUMP_MASK_CMP), TSN_DOMPATH_BIT_INS_JUMP_START_CMPFALSE, // jump: slot1 bit2, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_CMPFALSE, TSN_DOMPATH_BIT_INS_JUMP_MASK_CMP), TSN_DOMPATH_BIT_INS_JUMP_START_CMPFALSE, // jump: slot1 bit2, 28b
   },
   {
    5,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_COMPARE_MENOR_EQ},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_CMPFALSE, TSN_DOMPATH_BIT_INS_JUMP_MASK_CMP), TSN_DOMPATH_BIT_INS_JUMP_START_CMPFALSE, // jump: slot1 bit2, 28b
   },

//-- (jump vive en el SLOT 1: [type|k|jump][1=esperado])
   {
    4,
     {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, ASM_PARSER_TOKF_NUMBER, DOMPATH_QUERY_INS_TYPE_COMPARE_IS},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_JUMP_START_CMPIS_FALSE, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_JUMP_START_CMPIS_FALSE, // jump: slot0 bit36, 28b
   },

//--
   {4, {ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_CALL}}, // sin jump

//--
   {1, {DOMPATH_QUERY_INS_TYPE_RESERVE}}, // sin jump
   {
    5,
     {ASM_PARSER_TOKF_STR_HASH, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, ASM_PARSER_TOKF_NUMBER, DOMPATH_QUERY_INS_TYPE_SLICING},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_ETYPE, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_ETYPE, // jump: slot0 bit8, 28b
   },
   {
    2,
     {ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_JUMP},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_ETYPE, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_ETYPE, // jump: slot0 bit8, 28b (jump incondicional)
   },
   {
    2,
     {ASM_PARSER_TOKF_STR_HASH, DOMPATH_QUERY_INS_TYPE_COPY_ALL},
    TSN_DOMPATH_CREATE_MASK(TSN_DOMPATH_BIT_INS_ETYPE, TSN_DOMPATH_INS_MASK_INDEX_JMP), TSN_DOMPATH_BIT_INS_ETYPE, // jump: slot0 bit8, 28b
   },
   {1, {DOMPATH_QUERY_INS_TYPE_APPEND}}, // sin jump
   {1, {DOMPATH_QUERY_INS_TYPE_SALIDA}}, // sin jump
 };

//---
#define DOMPATH_QUERY_INS_TYPE_REG (DOMPATH_QUERY_INS_TYPE_SALIDA+1)

//---
enum ENUM_ASM_DOMPATH_PARSER_ERR
 {
  ASM_DOMPATH_PARSER_ERR_MALFORMERD_ASM,
  ASM_DOMPATH_PARSER_ERR_INVALID_INSTRUCTION,
  ASM_DOMPATH_PARSER_ERR_INVALID_TOKEN,
  ASM_DOMPATH_PARSER_ERR_JUMP_NOT_CLOSED,
  ASM_DOMPATH_PARSER_ERR_INVALID_CASE_INS,
  ASM_DOMPATH_PARSER_ERR_STRING_NOT_CLOSED,
  ASM_DOMPATH_PARSER_ERR_INVALID_JUMP_KEY,
  ASM_DOMPATH_PARSER_ERR_STR_HASH_NOT_CLOSED,
  ASM_DOMPATH_PARSER_ERR_NOT,
  ASM_DOMPATH_PARSER_ERR_MALFORMERD_ASM_CTX_GEN,
  ASM_DOMPATH_PARSER_ERR_FUNCTION_NOT_EXIST,
  ASM_DOMPATH_PARSER_ERR_COMENTARIO_NO_CERRO_Y_AUN_QUEDA_ALGO,
  ASM_DOMPATH_PARSER_ERR_INVALID_FILE_EXTENSION,
 };

//--- Tokens
enum ENUM_DOMPATH_ASM_PARSER_TOKENS
 {
  ASM_PARSER_TOK_REGISTER = 0, // %reg y algo
  ASM_PARSER_TOK_NUMBER, // mismo que integer
  ASM_PARSER_TOK_TRUE,
  ASM_PARSER_TOK_FALSE,
  ASM_PARSER_TOK_STRING,
  ASM_PARSER_TOK_S_STRING,
  ASM_PARSER_TOK_EQ,
  ASM_PARSER_TOK_STR_HASH,
  ASM_PARSER_TOK_PARSE_KEY_HASH,
  ASM_PARSER_TOK_COMMENT,
  ASM_PARSER_TOK_PARSE_INS, // instruccion #MUL
  ASM_PARSER_TOK_PARSE_END, // Delegar a especifica
  ASM_PARSER_TOK_PARSE_JUMP_S, // Jump start
  ASM_PARSER_TOK_INVALID
 };

//---- Palabra -> Token
// %=ASM_PARSER_TOK_REGISTER
// integer=se genera soo
// number= (0-9) inlcuye al signo '-'
// true= T\t (inicial)
// false= f\F
// string=S ()
// string_s="
// eq= '='
// keyhash (se geenra solo)
// coment ; o #
// makereg (Se genera oslo)
// parse ins = I
// parse end = se genera solo
// jump = @
// invlaid (cualquier no mencionada..)

const uchar g_dompath_asm_toks[256] =
 {
  ASM_PARSER_TOK_INVALID, //   0 0x00
  ASM_PARSER_TOK_INVALID, //   1 0x01
  ASM_PARSER_TOK_INVALID, //   2 0x02
  ASM_PARSER_TOK_INVALID, //   3 0x03
  ASM_PARSER_TOK_INVALID, //   4 0x04
  ASM_PARSER_TOK_INVALID, //   5 0x05
  ASM_PARSER_TOK_INVALID, //   6 0x06
  ASM_PARSER_TOK_INVALID, //   7 0x07
  ASM_PARSER_TOK_INVALID, //   8 0x08
  ASM_PARSER_TOK_INVALID, //   9 0x09
  ASM_PARSER_TOK_INVALID, //  10 0x0A
  ASM_PARSER_TOK_INVALID, //  11 0x0B
  ASM_PARSER_TOK_INVALID, //  12 0x0C
  ASM_PARSER_TOK_INVALID, //  13 0x0D
  ASM_PARSER_TOK_INVALID, //  14 0x0E
  ASM_PARSER_TOK_INVALID, //  15 0x0F
  ASM_PARSER_TOK_INVALID, //  16 0x10
  ASM_PARSER_TOK_INVALID, //  17 0x11
  ASM_PARSER_TOK_INVALID, //  18 0x12
  ASM_PARSER_TOK_INVALID, //  19 0x13
  ASM_PARSER_TOK_INVALID, //  20 0x14
  ASM_PARSER_TOK_INVALID, //  21 0x15
  ASM_PARSER_TOK_INVALID, //  22 0x16
  ASM_PARSER_TOK_INVALID, //  23 0x17
  ASM_PARSER_TOK_INVALID, //  24 0x18
  ASM_PARSER_TOK_INVALID, //  25 0x19
  ASM_PARSER_TOK_INVALID, //  26 0x1A
  ASM_PARSER_TOK_INVALID, //  27 0x1B
  ASM_PARSER_TOK_INVALID, //  28 0x1C
  ASM_PARSER_TOK_INVALID, //  29 0x1D
  ASM_PARSER_TOK_INVALID, //  30 0x1E
  ASM_PARSER_TOK_INVALID, //  31 0x1F
  ASM_PARSER_TOK_INVALID, //  32 0x20 (espacio, se salta antes de indexar)
  ASM_PARSER_TOK_INVALID, //  33 '!'
  ASM_PARSER_TOK_S_STRING, //  34 '"'
  ASM_PARSER_TOK_COMMENT, //  35 '#'
  ASM_PARSER_TOK_INVALID, //  36 '$'
  ASM_PARSER_TOK_REGISTER, //  37 '%'
  ASM_PARSER_TOK_INVALID, //  38 '&'
  ASM_PARSER_TOK_STR_HASH, //  39 '\''
  ASM_PARSER_TOK_INVALID, //  40 '('
  ASM_PARSER_TOK_INVALID, //  41 ')'
  ASM_PARSER_TOK_STR_HASH, //  42 '*'
  ASM_PARSER_TOK_INVALID, //  43 '+'
  ASM_PARSER_TOK_INVALID, //  44 ','
  ASM_PARSER_TOK_NUMBER, //  45 '-'
  ASM_PARSER_TOK_INVALID, //  46 '.'
  ASM_PARSER_TOK_INVALID, //  47 '/'
  ASM_PARSER_TOK_NUMBER, //  48 '0'
  ASM_PARSER_TOK_NUMBER, //  49 '1'
  ASM_PARSER_TOK_NUMBER, //  50 '2'
  ASM_PARSER_TOK_NUMBER, //  51 '3'
  ASM_PARSER_TOK_NUMBER, //  52 '4'
  ASM_PARSER_TOK_NUMBER, //  53 '5'
  ASM_PARSER_TOK_NUMBER, //  54 '6'
  ASM_PARSER_TOK_NUMBER, //  55 '7'
  ASM_PARSER_TOK_NUMBER, //  56 '8'
  ASM_PARSER_TOK_NUMBER, //  57 '9'
  ASM_PARSER_TOK_INVALID, //  58 ':'
  ASM_PARSER_TOK_COMMENT, //  59 ';'
  ASM_PARSER_TOK_INVALID, //  60 '<'
  ASM_PARSER_TOK_EQ, //  61 '='
  ASM_PARSER_TOK_INVALID, //  62 '>'
  ASM_PARSER_TOK_INVALID, //  63 '?'
  ASM_PARSER_TOK_PARSE_JUMP_S, //  64 '@'
  ASM_PARSER_TOK_INVALID, //  65 'A'
  ASM_PARSER_TOK_INVALID, //  66 'B'
  ASM_PARSER_TOK_INVALID, //  67 'C'
  ASM_PARSER_TOK_INVALID, //  68 'D'
  ASM_PARSER_TOK_INVALID, //  69 'E'
  ASM_PARSER_TOK_FALSE, //  70 'F'
  ASM_PARSER_TOK_INVALID, //  71 'G'
  ASM_PARSER_TOK_INVALID, //  72 'H'
  ASM_PARSER_TOK_PARSE_INS, //  73 'I' (todas las instrucciones empiezan con INS_*)
  ASM_PARSER_TOK_INVALID, //  74 'J'
  ASM_PARSER_TOK_PARSE_KEY_HASH, //  75 'K'
  ASM_PARSER_TOK_INVALID, //  76 'L'
  ASM_PARSER_TOK_INVALID, //  77 'M'
  ASM_PARSER_TOK_INVALID, //  78 'N'
  ASM_PARSER_TOK_INVALID, //  79 'O'
  ASM_PARSER_TOK_INVALID, //  80 'P'
  ASM_PARSER_TOK_INVALID, //  81 'Q'
  ASM_PARSER_TOK_INVALID, //  82 'R'
  ASM_PARSER_TOK_STRING, //  83 'S'
  ASM_PARSER_TOK_TRUE, //  84 'T'
  ASM_PARSER_TOK_INVALID, //  85 'U'
  ASM_PARSER_TOK_INVALID, //  86 'V'
  ASM_PARSER_TOK_INVALID, //  87 'W'
  ASM_PARSER_TOK_INVALID, //  88 'X'
  ASM_PARSER_TOK_INVALID, //  89 'Y'
  ASM_PARSER_TOK_INVALID, //  90 'Z'
  ASM_PARSER_TOK_INVALID, //  91 '['
  ASM_PARSER_TOK_INVALID, //  92 '\\'
  ASM_PARSER_TOK_INVALID, //  93 ']'
  ASM_PARSER_TOK_INVALID, //  94 '^'
  ASM_PARSER_TOK_INVALID, //  95 '_'
  ASM_PARSER_TOK_INVALID, //  96 '`'
  ASM_PARSER_TOK_INVALID, //  97 'a'
  ASM_PARSER_TOK_INVALID, //  98 'b'
  ASM_PARSER_TOK_INVALID, //  99 'c'
  ASM_PARSER_TOK_INVALID, // 100 'd'
  ASM_PARSER_TOK_INVALID, // 101 'e'
  ASM_PARSER_TOK_FALSE, // 102 'f'
  ASM_PARSER_TOK_INVALID, // 103 'g'
  ASM_PARSER_TOK_INVALID, // 104 'h'
  ASM_PARSER_TOK_INVALID, // 105 'i'
  ASM_PARSER_TOK_INVALID, // 106 'j'
  ASM_PARSER_TOK_INVALID, // 107 'k'
  ASM_PARSER_TOK_INVALID, // 108 'l'
  ASM_PARSER_TOK_INVALID, // 109 'm'
  ASM_PARSER_TOK_INVALID, // 110 'n'
  ASM_PARSER_TOK_INVALID, // 111 'o'
  ASM_PARSER_TOK_INVALID, // 112 'p'
  ASM_PARSER_TOK_INVALID, // 113 'q'
  ASM_PARSER_TOK_INVALID, // 114 'r'
  ASM_PARSER_TOK_INVALID, // 115 's'
  ASM_PARSER_TOK_TRUE, // 116 't'
  ASM_PARSER_TOK_INVALID, // 117 'u'
  ASM_PARSER_TOK_INVALID, // 118 'v'
  ASM_PARSER_TOK_INVALID, // 119 'w'
  ASM_PARSER_TOK_INVALID, // 120 'x'
  ASM_PARSER_TOK_INVALID, // 121 'y'
  ASM_PARSER_TOK_INVALID, // 122 'z'
  ASM_PARSER_TOK_INVALID, // 123 '{'
  ASM_PARSER_TOK_INVALID, // 124 '|'
  ASM_PARSER_TOK_INVALID, // 125 '}'
  ASM_PARSER_TOK_INVALID, // 126 '~'
  ASM_PARSER_TOK_INVALID, // 127 0x7F
  ASM_PARSER_TOK_INVALID, // 128 0x80
  ASM_PARSER_TOK_INVALID, // 129 0x81
  ASM_PARSER_TOK_INVALID, // 130 0x82
  ASM_PARSER_TOK_INVALID, // 131 0x83
  ASM_PARSER_TOK_INVALID, // 132 0x84
  ASM_PARSER_TOK_INVALID, // 133 0x85
  ASM_PARSER_TOK_INVALID, // 134 0x86
  ASM_PARSER_TOK_INVALID, // 135 0x87
  ASM_PARSER_TOK_INVALID, // 136 0x88
  ASM_PARSER_TOK_INVALID, // 137 0x89
  ASM_PARSER_TOK_INVALID, // 138 0x8A
  ASM_PARSER_TOK_INVALID, // 139 0x8B
  ASM_PARSER_TOK_INVALID, // 140 0x8C
  ASM_PARSER_TOK_INVALID, // 141 0x8D
  ASM_PARSER_TOK_INVALID, // 142 0x8E
  ASM_PARSER_TOK_INVALID, // 143 0x8F
  ASM_PARSER_TOK_INVALID, // 144 0x90
  ASM_PARSER_TOK_INVALID, // 145 0x91
  ASM_PARSER_TOK_INVALID, // 146 0x92
  ASM_PARSER_TOK_INVALID, // 147 0x93
  ASM_PARSER_TOK_INVALID, // 148 0x94
  ASM_PARSER_TOK_INVALID, // 149 0x95
  ASM_PARSER_TOK_INVALID, // 150 0x96
  ASM_PARSER_TOK_INVALID, // 151 0x97
  ASM_PARSER_TOK_INVALID, // 152 0x98
  ASM_PARSER_TOK_INVALID, // 153 0x99
  ASM_PARSER_TOK_INVALID, // 154 0x9A
  ASM_PARSER_TOK_INVALID, // 155 0x9B
  ASM_PARSER_TOK_INVALID, // 156 0x9C
  ASM_PARSER_TOK_INVALID, // 157 0x9D
  ASM_PARSER_TOK_INVALID, // 158 0x9E
  ASM_PARSER_TOK_INVALID, // 159 0x9F
  ASM_PARSER_TOK_INVALID, // 160 0xA0
  ASM_PARSER_TOK_INVALID, // 161 0xA1
  ASM_PARSER_TOK_INVALID, // 162 0xA2
  ASM_PARSER_TOK_INVALID, // 163 0xA3
  ASM_PARSER_TOK_INVALID, // 164 0xA4
  ASM_PARSER_TOK_INVALID, // 165 0xA5
  ASM_PARSER_TOK_INVALID, // 166 0xA6
  ASM_PARSER_TOK_INVALID, // 167 0xA7
  ASM_PARSER_TOK_INVALID, // 168 0xA8
  ASM_PARSER_TOK_INVALID, // 169 0xA9
  ASM_PARSER_TOK_INVALID, // 170 0xAA
  ASM_PARSER_TOK_INVALID, // 171 0xAB
  ASM_PARSER_TOK_INVALID, // 172 0xAC
  ASM_PARSER_TOK_INVALID, // 173 0xAD
  ASM_PARSER_TOK_INVALID, // 174 0xAE
  ASM_PARSER_TOK_INVALID, // 175 0xAF
  ASM_PARSER_TOK_INVALID, // 176 0xB0
  ASM_PARSER_TOK_INVALID, // 177 0xB1
  ASM_PARSER_TOK_INVALID, // 178 0xB2
  ASM_PARSER_TOK_INVALID, // 179 0xB3
  ASM_PARSER_TOK_INVALID, // 180 0xB4
  ASM_PARSER_TOK_INVALID, // 181 0xB5
  ASM_PARSER_TOK_INVALID, // 182 0xB6
  ASM_PARSER_TOK_INVALID, // 183 0xB7
  ASM_PARSER_TOK_INVALID, // 184 0xB8
  ASM_PARSER_TOK_INVALID, // 185 0xB9
  ASM_PARSER_TOK_INVALID, // 186 0xBA
  ASM_PARSER_TOK_INVALID, // 187 0xBB
  ASM_PARSER_TOK_INVALID, // 188 0xBC
  ASM_PARSER_TOK_INVALID, // 189 0xBD
  ASM_PARSER_TOK_INVALID, // 190 0xBE
  ASM_PARSER_TOK_INVALID, // 191 0xBF
  ASM_PARSER_TOK_INVALID, // 192 0xC0
  ASM_PARSER_TOK_INVALID, // 193 0xC1
  ASM_PARSER_TOK_INVALID, // 194 0xC2
  ASM_PARSER_TOK_INVALID, // 195 0xC3
  ASM_PARSER_TOK_INVALID, // 196 0xC4
  ASM_PARSER_TOK_INVALID, // 197 0xC5
  ASM_PARSER_TOK_INVALID, // 198 0xC6
  ASM_PARSER_TOK_INVALID, // 199 0xC7
  ASM_PARSER_TOK_INVALID, // 200 0xC8
  ASM_PARSER_TOK_INVALID, // 201 0xC9
  ASM_PARSER_TOK_INVALID, // 202 0xCA
  ASM_PARSER_TOK_INVALID, // 203 0xCB
  ASM_PARSER_TOK_INVALID, // 204 0xCC
  ASM_PARSER_TOK_INVALID, // 205 0xCD
  ASM_PARSER_TOK_INVALID, // 206 0xCE
  ASM_PARSER_TOK_INVALID, // 207 0xCF
  ASM_PARSER_TOK_INVALID, // 208 0xD0
  ASM_PARSER_TOK_INVALID, // 209 0xD1
  ASM_PARSER_TOK_INVALID, // 210 0xD2
  ASM_PARSER_TOK_INVALID, // 211 0xD3
  ASM_PARSER_TOK_INVALID, // 212 0xD4
  ASM_PARSER_TOK_INVALID, // 213 0xD5
  ASM_PARSER_TOK_INVALID, // 214 0xD6
  ASM_PARSER_TOK_INVALID, // 215 0xD7
  ASM_PARSER_TOK_INVALID, // 216 0xD8
  ASM_PARSER_TOK_INVALID, // 217 0xD9
  ASM_PARSER_TOK_INVALID, // 218 0xDA
  ASM_PARSER_TOK_INVALID, // 219 0xDB
  ASM_PARSER_TOK_INVALID, // 220 0xDC
  ASM_PARSER_TOK_INVALID, // 221 0xDD
  ASM_PARSER_TOK_INVALID, // 222 0xDE
  ASM_PARSER_TOK_INVALID, // 223 0xDF
  ASM_PARSER_TOK_INVALID, // 224 0xE0
  ASM_PARSER_TOK_INVALID, // 225 0xE1
  ASM_PARSER_TOK_INVALID, // 226 0xE2
  ASM_PARSER_TOK_INVALID, // 227 0xE3
  ASM_PARSER_TOK_INVALID, // 228 0xE4
  ASM_PARSER_TOK_INVALID, // 229 0xE5
  ASM_PARSER_TOK_INVALID, // 230 0xE6
  ASM_PARSER_TOK_INVALID, // 231 0xE7
  ASM_PARSER_TOK_INVALID, // 232 0xE8
  ASM_PARSER_TOK_INVALID, // 233 0xE9
  ASM_PARSER_TOK_INVALID, // 234 0xEA
  ASM_PARSER_TOK_INVALID, // 235 0xEB
  ASM_PARSER_TOK_INVALID, // 236 0xEC
  ASM_PARSER_TOK_INVALID, // 237 0xED
  ASM_PARSER_TOK_INVALID, // 238 0xEE
  ASM_PARSER_TOK_INVALID, // 239 0xEF
  ASM_PARSER_TOK_INVALID, // 240 0xF0
  ASM_PARSER_TOK_INVALID, // 241 0xF1
  ASM_PARSER_TOK_INVALID, // 242 0xF2
  ASM_PARSER_TOK_INVALID, // 243 0xF3
  ASM_PARSER_TOK_INVALID, // 244 0xF4
  ASM_PARSER_TOK_INVALID, // 245 0xF5
  ASM_PARSER_TOK_INVALID, // 246 0xF6
  ASM_PARSER_TOK_INVALID, // 247 0xF7
  ASM_PARSER_TOK_INVALID, // 248 0xF8
  ASM_PARSER_TOK_INVALID, // 249 0xF9
  ASM_PARSER_TOK_INVALID, // 250 0xFA
  ASM_PARSER_TOK_INVALID, // 251 0xFB
  ASM_PARSER_TOK_INVALID, // 252 0xFC
  ASM_PARSER_TOK_INVALID, // 253 0xFD
  ASM_PARSER_TOK_INVALID, // 254 0xFE
  ASM_PARSER_TOK_INVALID, // 255 0xFF
 };
}
//+------------------------------------------------------------------+
#endif // BASESPARSERSLAN_SRC_QUERY_ASMDEF_MQH