Agrego el Mitico y Enigmatico Word Scaping al block sorting. Para usarlo usar parame...

 PD : Puede fallar ;-)

diff --git a/src/blocksorting/bs.c b/src/blocksorting/bs.c
index 4ce8a12ff6be768cdd11dd05b035201663713aa3..b0010c1534e3a7d39291e4b87bb69e29caa11fd2 100644 (file)
--- a/src/blocksorting/bs.c
+++ b/src/blocksorting/bs.c
@@ -5,6 +5,95 @@
 
 /* Block Sorting Optimizado en memoria! */
 
+typedef struct _dict_ {
+       char *word;
+       int len;
+       int hits;
+} t_Diccionario;
+
+#define PALABRA(a) {a, sizeof(a)-1, 0}
+
+#define DICT_SIZE sizeof(dic)/sizeof(t_Diccionario)
+
+/* ASCII Numero 3 como caracter de escape */
+#define ESCAPE_CHARACTER 0x3
+
+/* Diccionario */
+t_Diccionario dic[] = {
+       /* Preposiciones (no todas) */
+       PALABRA(" ante"),
+       PALABRA(" bajo"),
+       PALABRA(" cabe"),
+       PALABRA(" con"),
+       PALABRA(" contra"),
+       /* PALABRA(" de"),  XXX No se si conviene, solo ahorra 1 byte y puede romper localidad */
+       PALABRA(" desde"),
+       PALABRA(" hasta"),
+       PALABRA(" hacia"),
+       PALABRA(" para"),
+       PALABRA(" por"),
+       PALABRA(" según"),
+       PALABRA(" sin"),
+       PALABRA(" sobre"),
+       PALABRA(" tras"),
+       PALABRA(" mediante"),
+       PALABRA(" durante"),
+
+       /* Articulos */
+       PALABRA(" el "),
+       PALABRA(" la "),
+       PALABRA(" ella "),
+       PALABRA(" del "),
+       PALABRA(" los "),
+       PALABRA(" las "),
+       PALABRA(" lo "),
+       PALABRA(" que"),
+       PALABRA(" una "),
+       PALABRA(" también"),
+       PALABRA(" tambien"),
+       PALABRA(" cuando"),
+       PALABRA(" pero"),
+       PALABRA(" todo"),
+       /* Otras de test */
+       PALABRA(" si "),
+       PALABRA(" mas "),
+       PALABRA(" más "),
+       PALABRA(" porque"),
+       PALABRA(" entonces"),
+       PALABRA(" siempre"),
+       PALABRA(" segundo"),
+       PALABRA(" programa"),
+       PALABRA(" existe"),
+       PALABRA(" recien"),
+       PALABRA(" máximo"),
+       PALABRA(" mínimo"),
+       PALABRA(" casi"),
+       PALABRA(" sección"),
+       PALABRA(" informe"),
+       PALABRA(" Informe"),
+       PALABRA(" acción"),
+       PALABRA(" perdedor"),
+       PALABRA(" existencia"),
+       PALABRA(" aire"),
+       PALABRA(" árbol"),
+       PALABRA(" prueba"),
+       PALABRA(" muestra"),
+       PALABRA(" animal"),
+       PALABRA(" suerte"),
+       PALABRA(" portador"),
+       PALABRA(" molesto"),
+       PALABRA(" cielo"),
+       PALABRA(" impulso"),
+       PALABRA(" alcohol"),
+       PALABRA(" seguido"),
+       PALABRA(" permiso"),
+       PALABRA(" cuarto"),
+       PALABRA(" brillante"),
+       PALABRA(" tener"),
+       PALABRA(" ningún"),
+       PALABRA(" fácil"),
+};
+
 typedef struct _bs_decode_t_ {
        char c;
        Uint32 sig;
@@ -163,28 +252,111 @@ void bs_EOL(char *data, Uint32 pagesize, Uint32 *j)
        (*j) += 9;
 }
 
-int bs_readblock(FILE *fp, char *data, Uint32 pagesize)
+char check_hint(char c)
+{
+       static int current_pos = 0;
+       char hits = 0;
+       int i;
+       char hit_pos = -1;
+
+       for(i=0; i<DICT_SIZE; i++) {
+               /* Veo de no pasarme */
+               if (current_pos < dic[i].len) {
+                       /* Si la palabra tiene suficientes hints */
+                       if (dic[i].hits == current_pos) {
+                               if (dic[i].word[current_pos] == c) {
+                                       dic[i].hits++;
+                                       hits++;
+                                       if (dic[i].hits == dic[i].len) {
+                                               hit_pos = i;
+                                       }
+                               } else {
+                                       /* Esta palabra ya no tiene posibilidades */
+                                       dic[i].hits = 0;
+                               }
+                       }
+               } else {
+                       dic[i].hits = 0;
+               }
+       }
+
+       current_pos++;
+
+       if (hits == 0) {
+               current_pos = 0;
+               return -1; /* No hay hints ! */
+       }
+       if (hits > 1) return -2; /* Tengo mas de 1 hint! */
+
+       if (hit_pos == -1) return -2; /* Tengo 1 solo hit pero no es completo */
+
+       /* Tengo 1 solo hint !!!! */
+       current_pos = 0;
+       return hit_pos;
+}
+
+void bs_clean_dic()
+{
+       int i;
+       for(i=0; i<DICT_SIZE; i++) {
+               dic[i].hits = 0;
+       }
+}
+
+int bs_readblock(FILE *fp, char *data, Uint32 pagesize, int usar_dic)
 {
        Uint32 i=0;
-       char c;
-       while ((!feof(fp)) && (i < pagesize)) {
+       char c, hint;
+       char buffer[100];
+       int j, buffer_pos=0;
+
+       while ((!feof(fp)) && ((i+buffer_pos) < pagesize)) {
                c = fgetc(fp);
-/*             if (c != '\n')*/
-               if (c == 0x01) {
-                       /* Debo encodear el \0 para que no complique */
-                       data[i++] = 0x01;
-                       data[i++] = 0xFF;
-               }
-               if (isupper(c)) {
-                       data[i++] = 0x01;
-                       data[i++] = tolower(c);
-               } else {
+               hint = check_hint(c);
+
+               if (usar_dic != 1) {
                        data[i++] = c;
+                       continue;
+               }
+
+               switch (hint) {
+                       case -1:
+                               /* No hay hints, vacio el buffer y luego saco el c */
+                               for(j=0; j<buffer_pos; j++)
+                                       data[i++] = buffer[j];
+
+                               data[i++] = c;
+                               buffer_pos = 0;
+                               bs_clean_dic();
+                       break;
+                       case -2:
+                               /* Tengo mas de 1 hit, tengo posibilidades, guardo este char en el buffer */
+                               buffer[buffer_pos++] = c;
+                       break;
+                       default:
+                               /* Me retornaron un numero positivo!!, eso quiere decir que ese numero
+                                * es la posicion dentro del diccionario de la palabra que puedo reemplazar
+                                */
+                               data[i++] = ESCAPE_CHARACTER;
+                               /* Trato de hacer que el caracter sea comun en textos, para que no me rompa
+                                * la localidad
+                                */
+                               data[i++] = hint+32;
+                               bs_clean_dic();
+                               /* Imprimo el buffer que deberia ser la palabra que reemplazo */
+/*                             {
+                                       int iii;
+                                       for(iii=0; iii<buffer_pos; iii++)
+                                               printf("%c", buffer[iii]);
+                                       printf("%c\n", c);
+                               }                                       */
+                               /* El buffer no lo necesito mas */
+                               buffer_pos = 0;
                }
-/*             else
-                       bs_EOL(data, pagesize, &i);*/
        }
 
+       for(j=0; j<buffer_pos; j++)
+               data[i++] = buffer[j];
        /* Saco un EOF que lee de mas */
        if (i<pagesize) i--;
 

diff --git a/src/blocksorting/bs.h b/src/blocksorting/bs.h
index 7e686ee5142312bdcda2224e67d376180562eb58..0cfec7fd05080bc32f4ed6ab41ac097ca18f3f55 100644 (file)
--- a/src/blocksorting/bs.h
+++ b/src/blocksorting/bs.h
@@ -56,7 +56,7 @@ void bs_solve(char *in, char *out, t_BlockSort *bs, Uint32 *k, Uint32 leido);
  */
 void bs_restore(char *dst, char *c, Uint32 k, Uint32 len);
 
-int bs_readblock(FILE *fp, char *data, Uint32 pagesize);
+int bs_readblock(FILE *fp, char *data, Uint32 pagesize, int usar_dic);
 
 #endif
 

diff --git a/src/blocksorting/main.c b/src/blocksorting/main.c
index 91582a92ccd7c6607a99b64f1e4f14a14917c62c..56e849b34caa8239de7c17023beb5b272a71eb66 100644 (file)
--- a/src/blocksorting/main.c
+++ b/src/blocksorting/main.c
@@ -1,6 +1,21 @@
 
 #include "bs.h"
 
+void print_v(char *txt, char *data, Uint32 len)
+{
+       Uint32 i;
+
+       printf("%s", txt);
+       
+       for(i=0; i<len; i++) {
+               if (data[i] == '\n')
+                       printf("#");
+               else
+                       printf("%c", data[i]);
+       }
+       printf("\n");
+}
+
 int main(int argc, char *argv[])
 {
        char *data; 
@@ -23,7 +38,7 @@ int main(int argc, char *argv[])
        }
 
        data = malloc(sizeof(char)*len);
-       salida = malloc(sizeof(char)*(len+1+sizeof(unsigned long int)*2));
+       salida = malloc(sizeof(char)*(len+1+sizeof(unsigned long int)));
        orig = malloc(sizeof(char)*(len+1));
 
        salida[len] = '\0';
@@ -31,27 +46,21 @@ int main(int argc, char *argv[])
 
        bs = bs_create(len);
 
-       c = fgetc(fp);
        total = 0;
        while (!feof(fp)) {
                i = 0;
-               while ((!feof(fp)) && (i < len)) {
-                       data[i++] = c;
-                       c = fgetc(fp);
-                       total++;
-               }
-               /* lleno data mano! */
-               srand(time(NULL));
-               {
-                       size_t jj;
-                       for(jj=0; jj<i;jj++)
-                               data[jj] = rand()%255;
-               }
+               i = bs_readblock(fp, data, len, 1);
+               
+               total += i;
+               
                bs_solve(data, salida, bs, &k, i);
 
                /* XXX ACA SALIDA DEBERIA PASAR A LA SIGUIENTE ETAPA XXX */
                if (argc == 3) {
-                       bs_restore(orig, salida+sizeof(Uint32)*2, k, i);
+                       bs_restore(orig, salida+sizeof(Uint32), k, i);
+                       print_v("Leido     : ", data, i);
+                       print_v("BS        : ", salida+sizeof(Uint32), i);
+                       /*print_v("Restorado : ", orig, i);*/
                } else
                        fwrite(salida, 1, i, stdout);
        }

diff --git a/src/jacu.c b/src/jacu.c
index 75ca87ccadfeccf070a53fdaf7b7194be5ed85f3..1648e82eb0b6599a62c98fcf1e861af59f6ef9ed 100644 (file)
--- a/src/jacu.c
+++ b/src/jacu.c
@@ -20,6 +20,7 @@ typedef struct _flags_ {
        int qflag;
        int sflag;
        int mflag;
+       int rflag; /* Richard Dictionary :-) */
 } t_Flags;
 
 int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags *flags, char *staticmodel);
@@ -35,7 +36,7 @@ int main(int argc, char* argv[])
                        
        memset(&flags, 0, sizeof(t_Flags));
 
-       while ((ch = getopt(argc, argv, "scdzm:t:q:")) != -1) { 
+       while ((ch = getopt(argc, argv, "rscdzm:t:q:")) != -1) { 
                 
                switch (ch) { 
                        case 'c': flags.cflag = 1; 
@@ -58,6 +59,8 @@ int main(int argc, char* argv[])
                                volumesize = atol(optarg);
                                break; 
 
+                       case 'r': flags.rflag = 1;
+                               break;
                        case 'q': flags.qflag = 1; 
                                switch (atoi(optarg))
                                {
@@ -85,13 +88,13 @@ int main(int argc, char* argv[])
                                }
                                break; 
 
-                       default: fprintf(stderr, "Usage: %s [-cdzs][-q blksize][-t volsize][-m modeldumpfile] source target\n", argv[0]); 
+                       default: fprintf(stderr, "Usage: %s [-cdzsr][-q blksize][-t volsize][-m modeldumpfile] source target\n", argv[0]); 
                                         return(2);
                }
        }
                
        if ( (argc == 1) || (flags.cflag & flags.dflag) || !(flags.cflag | flags.dflag) || ((argc - optind) < 2) || (flags.mflag & flags.sflag)) {
-               fprintf(stderr, "Usage: %s [-cdzs][-q compressionquality][-t volsize][-m modeldumpfile] source target\n", argv[0]); 
+               fprintf(stderr, "Usage: %s [-cdzsr][-q compressionquality][-t volsize][-m modeldumpfile] source target\n", argv[0]); 
                return (3);
        }
        if ((flags.tflag) && (volumesize <= 0l)) {
@@ -161,7 +164,7 @@ int comprimir(char *src, char *dst, Uint32 pagesize, Uint32 volumesize, t_Flags
        total = 0;
        while (!feof(fp)) {
                i = 0;
-               i = bs_readblock(fp, data, pagesize);
+               i = bs_readblock(fp, data, pagesize, flags->rflag);
                total += i;