src/zerogrouping/zerogrouping.c

   1 /* vim: set noexpandtab tabstop=4 shiftwidth=4 wrap:
   2  *----------------------------------------------------------------------------
   3  *                                  jacu
   4  *----------------------------------------------------------------------------
   5  * This file is part of jacu.
   6  *
   7  * jacu is free software; you can redistribute it and/or modify it under the
   8  * terms of the GNU General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option) any later
  10  * version.
  11  *
  12  * jacu is distributed in the hope that it will be useful, but WITHOUT ANY
  13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15  * details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with jacu; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  *----------------------------------------------------------------------------
  21  * Creado:  lun jun 21 05:40:38 ART 2004
  22  * Autores: Leandro Lucarella <llucare@fi.uba.ar>
  23  *----------------------------------------------------------------------------
  24  *
  25  * $Id$
  26  *
  27  */
  28
  29 #include "zerogrouping.h"
  30
  31 /** \file
  32  *
  33  * Agrupador de ceros.
  34  *
  35  * Implementación del agrupador de ceros. TODO completar doc.
  36  *
  37  */
  38
  39 void zg_init(ZG* zg)
  40 {
  41         zg->in_zero = 0;
  42 }
  43
  44 /** FIXME
  45  * El dst se asume que tiene al menos 2 bytes reservados para escribir,
  46  * por si se llegara a expandir. src es el caracter a encodear. Se
  47  * devuelve la cantidad de bytes escritos en dst. */
  48 size_t zg_group(ZG* zg, char *dst, char src)
  49 {
  50         if (src == 0)
  51         {
  52                 if (zg->in_zero)
  53                 {
  54                         zg->count++; /* FIXME verificar que no pase 255 */
  55                         return 0; /* indico que no hay nada */
  56                 }
  57                 else
  58                 {
  59                         zg->in_zero = 1; /* entramos en serie de ceros */
  60                         zg->count = 0; /* reiniciamos contador de ceros */
  61                         *dst = 0; /* devuelvo el cero */
  62                         return 1; /* indico que hay un caracter */
  63                 }
  64         }
  65         else /* no es un cero */
  66         {
  67                 size_t ret = 1;
  68                 if (zg->in_zero)
  69                 {
  70                         zg->in_zero = 0; /* salgo de serie de ceros */
  71                         *dst = zg->count; /* devuelvo cantidad de ceros */
  72                         dst++; /* me muevo al siguiente caracter */
  73                         ret++; /* indico que hay un caracter más */
  74                 }
  75                 *dst = src; /* devuelvo el caracter */
  76                 return ret; /* indico la cantidad de caracteres devueltos */
  77         }
  78 }
  79
  80 /** FIXME
  81  * dst debe tener reservado al menos 256 bytes, src es el caracter a desencodear
  82  * y se devuelven la cantidad de bytes desencodeados en dst. */
  83 size_t zg_ungroup(ZG* zg, char *dst, char src)
  84 {
  85         if (src == 0)
  86         {
  87                 if (zg->in_zero) /* eran 2 ceros seguidos (1 cero orig. expandido) */
  88                 {
  89                         zg->in_zero = 0; /* saldo de serie de ceros */
  90                         return 0; /* indico que no hay nada */
  91                 }
  92                 else /* empieza serie de ceros */
  93                 {
  94                         zg->in_zero = 1; /* entramos en serie de ceros */
  95                         *dst = 0; /* devuelvo el cero */
  96                         return 1; /* indico que hay un caracter */
  97                 }
  98         }
  99         else /* no es un cero */
 100         {
 101                 if (zg->in_zero) /* era una serie de ceros comprimida */
 102                 {
 103                         char ret = src;
 104                         zg->in_zero = 0; /* salgo de serie de ceros */
 105                         while (src--) dst[(size_t)src] = 0; /* devuelve src cantidad de ceros */
 106                         return ret; /* indica que se devolvieron src cantidad de ceros */
 107                 }
 108                 else
 109                 {
 110                         *dst = src; /* devuelvo el caracter */
 111                         return 1; /* indico que se devolvió un caracter */
 112                 }
 113         }
 114 }
 115