Bugfixes y nueva funciónp para terminar de agrupar bien.

diff --git a/src/zerogrouping/zerogrouping.c b/src/zerogrouping/zerogrouping.c
index 4ee92f56d6bc5a7bc15413f1fc8e728322ffea02..569b9ad0c35e2cda72d3f22a83be0144d5e87383 100644 (file)
--- a/src/zerogrouping/zerogrouping.c
+++ b/src/zerogrouping/zerogrouping.c
@@ -45,13 +45,18 @@ void zg_init(ZG* zg)
  * El dst se asume que tiene al menos 2 bytes reservados para escribir,
  * por si se llegara a expandir. src es el caracter a encodear. Se
  * devuelve la cantidad de bytes escritos en dst. */
-size_t zg_group(ZG* zg, char *dst, char src)
+size_t zg_group(ZG* zg, unsigned char *dst, unsigned char src)
 {
        if (src == 0)
        {
                if (zg->in_zero)
                {
-                       zg->count++; /* FIXME verificar que no pase 255 */
+                       if (++(zg->count) == 255u) /* si es 255, salgo de serie de ceros */
+                       {
+                               zg->in_zero = 0; /* salgo de serie de ceros */
+                               *dst = zg->count; /* devuelvo cantidad de ceros */
+                               return 1; /* indico que hay un caracter */
+                       }
                        return 0; /* indico que no hay nada */
                }
                else
@@ -77,10 +82,22 @@ size_t zg_group(ZG* zg, char *dst, char src)
        }
 }
 
+/** A lo sumo puede devolver un unsigned char */
+size_t zg_group_finish(ZG* zg, unsigned char *dst)
+{
+       if (zg->in_zero) /* sólo me interesa si estaba en una serie de ceros */
+       {
+               zg->in_zero = 0; /* salgo de serie de ceros */
+               *dst = zg->count; /* devuelvo cantidad de ceros */
+               return 1; /* indico que hay un caracter */
+       }
+       return 0; /* no había nada */
+}
+
 /** FIXME
  * dst debe tener reservado al menos 256 bytes, src es el caracter a desencodear
  * y se devuelven la cantidad de bytes desencodeados en dst. */
-size_t zg_ungroup(ZG* zg, char *dst, char src)
+size_t zg_ungroup(ZG* zg, unsigned char *dst, unsigned char src)
 {
        if (src == 0)
        {
@@ -100,7 +117,7 @@ size_t zg_ungroup(ZG* zg, char *dst, char src)
        {
                if (zg->in_zero) /* era una serie de ceros comprimida */
                {
-                       char ret = src;
+                       unsigned char ret = src;
                        zg->in_zero = 0; /* salgo de serie de ceros */
                        while (src--) dst[(size_t)src] = 0; /* devuelve src cantidad de ceros */
                        return ret; /* indica que se devolvieron src cantidad de ceros */

diff --git a/src/zerogrouping/zerogrouping.h b/src/zerogrouping/zerogrouping.h
index b1b9a2eedad7bf8babcd7e2b6b6ba87242bc2e4d..74e088ac0b8608338e6f03573de021a32b0a8408 100644 (file)
--- a/src/zerogrouping/zerogrouping.h
+++ b/src/zerogrouping/zerogrouping.h
@@ -42,8 +42,8 @@
 /** Estado del agrupador de ceros. */
 typedef struct
 {
-       char count;   /**< Cantidad de ceros acumulados. */
-       int  in_zero; /**< Indica si está en una serie de ceros. */
+       unsigned char count; /**< Cantidad de ceros acumulados. */
+       int  in_zero;        /**< Indica si está en una serie de ceros. */
 }
 ZG;
 
@@ -52,10 +52,14 @@ void zg_init(ZG* zg);
 
 /** Agrupa varios ceros seguis en 2 bytes, el primero es cero y el segundo la
  * cantidad. FIXME */
-size_t zg_group(ZG* zg, char *dst, char src);
+size_t zg_group(ZG* zg, unsigned char *dst, unsigned char src);
+
+/** Termina de obtener ceros agrupados por zg_group(), si los hubiera.
+ * FIXME */
+size_t zg_group_finish(ZG* zg, unsigned char *dst);
 
 /** Vuelve al original. FIXME */
-size_t zg_ungroup(ZG* zg, char *dst, char src);
+size_t zg_ungroup(ZG* zg, unsigned char *dst, unsigned char src);
 
 #endif /* _JACU_ZG_H_ */
 

diff --git a/src/zerogrouping/zg.c b/src/zerogrouping/zg.c
index 7d93343ddc05e565b6a3605b6bf08ce60584974d..779694fd61e089f9cb88d391aa032281d4f5b4ee 100644 (file)
--- a/src/zerogrouping/zg.c
+++ b/src/zerogrouping/zg.c
@@ -47,6 +47,8 @@ int main()
        {
                if ((len = zg_group(&zg, buff, c))) fwrite(buff, 1, len, stdout);
        }
+       /* imprimo si quedó algo en el buffer */
+       if ((len = zg_group_finish(&zg, buff))) fwrite(buff, 1, len, stdout);
        return 0;
 }