el _z estaba alocando mas memoria de la que necesitaba, pero creo que eso no producia...

[z.facultad/75.06/jacu.git] / src / zerogrouping / zerogrouping.c

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 */