JsonParserByLeo/Test/UEPar.mq5

//+------------------------------------------------------------------+
//|                                                        UEPar.mq5 |
//|                                  Copyright 2026, Niquel Mendoza. |
//|                                            https://www.mql5.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza."
#property link      "https://www.mql5.com/"
#property version   "1.00"
#property strict

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define TSNTABLES_SWAR_MASK_BACK_SLASH  (0x5C5C5C5C5C5C5C5C)
#define TSNTABLES_SWAR_MASK_COMILLA     (0x2222222222222222)
#define TSNTABLES_SWAR_LO 0x0101010101010101
#define TSNTABLES_SWAR_HI 0x8080808080808080
#define TSNTABLES_SWAR_HAS(mask) ((mask - TSNTABLES_SWAR_LO) & ~mask & TSNTABLES_SWAR_HI)

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
template <typename T>
string ToBits(T v)
 {
  string str = "";
  for(int i = (sizeof(T) << 3) - 1 ; i >= 0; i--)
   {
    str += string(uchar((v & (1ULL << i)) == 0 ? 0 : 1));
   }
  return str;
 }
//+------------------------------------------------------------------+
// 110
// 010


//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
 {
  union U
   {
    ulong v;
    uchar data[8];
   };

  U va;
  va.data[0] = '"';
  va.data[1] = '\\';
  va.data[2] = '"';
  va.data[3] = 'b';
  va.data[4] = '{';
  va.data[5] = 'g';
  va.data[6] = '"';
  va.data[7] = '1';
// 8=\
// 9=\


  ulong str = va.v;

//---
// 1100 0000 10
// 1100 0000 1100 0000
// 0000 0000

//---
  ulong x_bs = str ^ TSNTABLES_SWAR_MASK_BACK_SLASH;
  ulong x_qt = str ^ TSNTABLES_SWAR_MASK_COMILLA;
  ulong has_bs = TSNTABLES_SWAR_HAS(x_bs);
  ulong has_qt = TSNTABLES_SWAR_HAS(x_qt);


//--- Metodo base
  ulong bits = has_bs >> 7;
  const ulong magic = 0x0102040810204080;
  const uchar compacted_bs = uchar(((bits * magic) >> 56) & 0xFF);
  Print(ToBits(compacted_bs));
  const uchar even_mask = B'10101010';

  uchar a = (((compacted_bs << 1) | even_mask) - compacted_bs) ^ even_mask;
  Print("Dez: ");
  Print(ToBits(uchar(compacted_bs << 1)));
  Print("Or with impar: ");
  Print(ToBits(uchar((compacted_bs << 1) | even_mask)));
  Print("Minus: ");
  Print(ToBits(uchar(((compacted_bs << 1) | even_mask) - compacted_bs)));
  Print("Final:");
  Print(ToBits(a));

  uchar escaped = a ^ compacted_bs;
  uchar escape = (a & compacted_bs) >> 7;
  Print("overflow: ", escape);

  /* uchar starts = compacted_bs & ~(compacted_bs << 1);
   Print("starts");
   Print(ToBits(starts));

   uchar starts_par   = starts & even_mask;
   uchar starts_impar = starts & ~even_mask;



   Print("starts f");
   Print(ToBits(starts_par));
   Print(ToBits(starts_impar));
   uchar sum_par   = compacted_bs + starts_par;
   const ushort sum_impar_wide = (ushort)compacted_bs + ushort(starts_impar);
   Print("sum f");

   Print(ToBits(sum_par));
   Print(ToBits(sum_impar_wide));


   uchar end_par   = sum_par & ~compacted_bs;
   uchar end_impar = uchar(sum_impar_wide & 0xff)   & ~compacted_bs;
   Print("end");
   Print(ToBits(end_par));
   Print(ToBits(end_impar));

   Print("---");
   Print("ImPar mask : ", ToBits(even_mask));
   Print("Par mask   : ", ToBits(uchar(~even_mask)));
   Print("end impr mask: ", ToBits(uchar(end_impar & even_mask)));
   Print("end par mask : ", ToBits(uchar(end_par & ~even_mask)));

   uchar end_final = (end_impar & even_mask) | (end_par & ~even_mask);
   Print("end final");

   Print(ToBits(end_final));


   Print(ToBits(Q_real));*/


  bits = has_qt >> 7;
  const uchar compacted_qt = uchar(((bits * magic) >> 56) & 0xFF);
  uchar Q_real = compacted_qt & ~escaped;
  Print(ToBits(Q_real));


  Q_real ^= Q_real << 1;
  Q_real ^= Q_real << 2;
  Q_real ^= Q_real << 4;

  Print(ToBits(Q_real));

  uchar prev_in_string = 0U;

  const uchar in_string = Q_real ^ prev_in_string;
  Print(ToBits(in_string));


  prev_in_string = uchar(char(in_string) >> 7);
  Print(ToBits(prev_in_string));
 }

//+------------------------------------------------------------------+
/*
  00000001
  \\a\\\b"
  11011100 <<1
// A este punto ya se tendriaa los caracteres qeu son escapados
// Bastaria con un AND Para terminar pero nota que hay un tema el overflow
// Y los impares y el tema de las rachas.. creo qeu eso solo funcionara si no
// hubieran rachas y solo \ dispersos ahi si te draia los chars que se "escapan"
  10111000

// Bueno a difernica del otro algoritmo que note qeu es mas grande
// dado que separa en dos rutas el tema de pares\impares
// obtiebne inicios y con accareo los fines de las rachas y luego compara
// con posiciones y se apagan\prendn bits dependei si es valido
// Acada la idea es no hacen todo ese trabajo si no solo ver los chars
// Que se escapan y no se escapan en base a eso luego aplicaremo la mascara final
// Ahora con el or lo que haremos sera añadirle una mascara con los impartes
// Por lo qeu vi esto tiene que ver ocn la resta que viene..
// Dado uqe con eso el tema del prestamo que sehace y tambien las posiciones
// Impares
// Dado que las posiciones imapres.. para que quede espcaod
// EL caracter final (+1) debe quedar en posicion par
// Entonces con las rachas esto creo qeu normaliza inciae,te
// Lugeo igual se decahe con un xor (aun no me queda muy calro a decir verdad)
// Pero si ver el resultado del esciprt empiza a tener sentdio
  10111000 | or
  10101010
  --------
  10111010

// Luego de eso aplicamos una resta esto es interesante dadao
// Que como esmotas resntando uno "norma" y otr odesfasdo enotnces incial
// resta 0-1 lo qeu descandena ese "prestamo".. el tema es que
// mietrnas dure la racha ira repestandose luego al terminar la racha cuando
// se restop con 0 ahi termina creo que la idea aqui era como mezaclar
// ese reusltao hace que con ese or pareec que todo qeuda "pares"
// Lo otro interesante es qeu aun el resutlado esta a medias
// No peudefs scaar conlcusion luego con el xor final se limpia mas
// Y queda que los pares su caracter inicla queda como 0
// luego los impares el caracter a escapar qeuda como 1..
// Esto es porducot de la resta y eso de los paraes muy psible sea por el | or que hicmos
  10111010 -
  11011100
  --------
  11011110

// Ahora limpaismo con xor (los iguales en si los 1-1 se ahcen 0)
  11011110 xor
  10101010
  --------
  01110100

// Por ultimo aplicamos otro xor pero ya no liapdf la msarca si no sobre
// El conujutno real esto lo que nos deja es 1 en las posicones que se "escapan"
// Luego la idea sera voltear este reusltado y apliucar un and sobre el qt
// y ahi sacas las posicones que se requiren
  01110100
  11011100 xor
  --------
  10101000

  01110
  0001
   111
*/

//+------------------------------------------------------------------+
// 11011100     Base
// 10111000     << 1 para deteerminar el fin de cada racha y el bit niical de cada racha queda en 0 (previo a una rahca hay un 0)
// Ahora volteas el reusltoad y ahora donde habia 0 hay 1... lo intresante es que los incios de las rachas ahora tienen
// 01000111     ~
// un 1.. entonces loq eu falta por hacer es dejar eoss 1.. eso lo haremos ahora..
//---
// 01000111 & // para limpiar
// 11011100
// 01000100
// A este punto tenemos 1 en donde empizar las rachas..
// ahora la idea sera versi son impartes o pares.. si son pares aisalmos los bits donde son el fin de la racha
// y luego aplicamsoo una mascara de " y ahi nos da los que si son
//---
// Luego se hace and con mascaras con pares.. la idea es procesar por
// separado las maracas de rachas pares e impares.
//--- Starts par por ejemplo..
// 01000100  (se queda tal cual)
// 11011100 + // se suma con los starts esto hace que se valle prestando 1 (1+1 inicial) y al final de la racha par deje un bit prendido
//[1]00100000
// Luego la idea es que pro ejemplo con las rachas pares seapramos su inico...
// Y marcamos los incios pares ahi...
// Luego con acarreo tenemos los finaes..
// Ahora para los inicios pares.. la idea es que tambien acaben en posiciones pares (caracter + 1)
// ejemplo [0][1][2]
//          \  \     aqui si acaba en un par (buneo un impar + 1) en este caso acabo en 2
// entonces bien.... aqui se qeudaira un bit prendido en 1 luego cuando combinemos ambas rachas
// para los pares negamos la mascara de 01010101  osea se hace una mascara de impares
// la idea e sque al hacer and en caso la racha acabe en impares... su bit se mantine esi no se hace 10
// esto es interensate luego que en la negacion final.. esos bits pasan a ser 0.. (los 1..)
// es como una liuempiza.. entonces quedan los bits prendidos los end validos... no escapados
// luego ahi una and con la mcarsa de qt y listo qeudan los bits con " validos