Agrego manejo de flags en el header, en total se puden usar hasta 8 flahs. 2 usadas

[z.facultad/75.06/jacu.git] / src / blocksorting / bs.c

diff --git a/src/blocksorting/bs.c b/src/blocksorting/bs.c
index 4ce8a12ff6be768cdd11dd05b035201663713aa3..a71e2619fea21c11416414108adb595861227d98 100644 (file)
--- a/src/blocksorting/bs.c
+++ b/src/blocksorting/bs.c
@@ -5,6 +5,95 @@
 
 /* Block Sorting Optimizado en memoria! */
 
 
 /* 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;
 typedef struct _bs_decode_t_ {
        char c;
        Uint32 sig;


@@ -163,31 +252,151 @@ void bs_EOL(char *data, Uint32 pagesize, Uint32 *j)
        (*j) += 9;
 }
 
        (*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;
 {
        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);
                c = fgetc(fp);

-/*             if (c != '\n')*/
-               if (c == 0x01) {
-                       /* Debo encodear el \0 para que no complique */
-                       data[i++] = 0x01;
-                       data[i++] = 0xFF;
+               
+               if (usar_dic != 1) {
+                       data[i++] = c;
+                       continue;

                }
                }

-               if (isupper(c)) {
-                       data[i++] = 0x01;
-                       data[i++] = tolower(c);
-               } else {
+
+               if (c == ESCAPE_CHARACTER) {

                        data[i++] = c;
                        data[i++] = c;

+                       data[i++] = 0xF;
+                       bs_clean_dic();
+                       continue;
+               }
+
+               hint = check_hint(c);
+
+               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;
+                               bs_clean_dic();
+                               /* 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--;
 
        return i;
 }
 
        /* Saco un EOF que lee de mas */
        if (i<pagesize) i--;
 
        return i;
 }
 

+char *bs_finalblock(char *data, Uint32 len, Uint32 *new_size)
+{
+       Uint32 size=0, i, j;
+       char *out = NULL;
+       unsigned char tmp;
+
+       for(i=0; i < len; i++) {
+               if (data[i] == ESCAPE_CHARACTER) {
+                       i++;
+                       if (data[i] == 0xF) {
+                               /* Solo tengo que dejar el ESCAPE_CHARACTER */
+                               size++;
+                               out = (char *)realloc(out, size*sizeof(char));
+                               out[size-1] = data[i];
+                               /* Salteo ese caracter */
+                       } else {
+                               /* Va una palabra!! */
+                               tmp = data[i];
+                               size += dic[(size_t)tmp].len;
+                               out = (char *)realloc(out, size*sizeof(char));
+                               for(j=0; j<dic[(size_t)tmp].len; j++) {
+                                       out[size-dic[(size_t)tmp].len+j] = dic[(size_t)tmp].word[j];
+                               }
+                               /* Salteo el caracter siguiente al de escape */
+                       }
+               } else {
+                       size++;
+                       out = (char *)realloc(out, size*sizeof(char));
+                       out[size-1] = data[i];
+               }
+       }
+
+       (*new_size) = size;
+       return out;
+}
+