🚀 go-pugleaf

CJR wrote:
> void send(int* to, int* from, int count)
> {
>         int n = (count+7)/8;
>         switch(count%8) {
>         case 0: do { *to++ = *from++;
>        case 7:         *to++ = *from++;
>        case 6:         *to++ = *from++;
>        case 5:         *to++ = *from++;
>        case 4:         *to++ = *from++;
>        case 3:         *to++ = *from++;
>        case 2:         *to++ = *from++;
>        case 1:         *to++ = *from++;
>                 } while (--n>0);
>         }
> }

Esto parece ser un programa que copia "count" enteros desde
el vector "from" al vector "to". Solo que complicandose la
vida y con el caso particular de que si se ejecuta con count=0, 
copia 8 enteros.

La forma de interpretarla es teniendo en cuenta que no existe
"break"s en el switch-case. Eso significa que si count%8 es
0, se ejecutaran los ocho *to++ = *from++ que son los que
hacen la copia. Si es 7, se ejecutara 7 veces, si 6 ,6 veces,etc.

El int n = (count+7)/8 lo he visto muchas veces en ensamblador
del DOS. Se usaba para calcular la memoria que debías reservar
en segmentos (bloques de 16 bytes) para una cantidad de elementos
variable. Se hacía segmentos=(bytes+15)/16 pues tiene la bonita
propiedad de que si vas a reservar 0 bytes, te salen 0 segmentos.
En cuanto necesitabas un byte, ya te salía un segmento, igual
para 2 bytes, 3.... hasta 16. Cuando eran 17 ya te salían dos
segmentos (como debía ser). Es una forma de calcular ((n-1)/8)+1
y es el número más uno de copias de bloques de 8 bytes que se 
realizarán.

El operador % sirve para hallar el resto de la division y el / 
es para la división entera. 

Así, si count es 1, n es 1 y al llegar al switch salta al case 1
copia un byte,y al llegar al bucle que cierra, la condición no se 
cumple por lo que termina y acaba la rutina.

Si es count es 2, igual solo que saltará al case 2 y copiará dos
bytes.

Así, igual hasta count = 7. Cuando vale 8, el resto de la división
entre 8 es cero, pero n sigue valiendo 1, por lo que salta al 
case 0, hace las 8 copias y acaba la rutina.

Cuando count=9, n ya vale 2 y el resto de la división 1. Por tanto
salta al case 1 haciendo una copia con lo que llega al final del
bucle. La condición --n>0 se cumple por tanto el programa se va
a despues del do, que es donde comienza el bucle. En el bucle hará
8 copias más por lo que en total habrá copiado nueve bytes, como
debe ser. Así sucesivamente.

El caso particular count=0, hace que el resto salga 0, por lo que
se ejecuta el do y las 8 copias. Y al no cumplirse la condición del
while acaba la rutina.

Así, el programa hace primero tantas copias como el resto de count
entre 8 (salvo en caso de resto cero en el que hace 8 copias).
Despues hace (count/8) veces 8 copias de bytes, salvo en caso de
que count sea multiplo de 8, en la que hace una vez menos.
Así si count no es multiplo de 8 copia este número de elementos:

resto(count/8)+8*cociente(count/8)

Que facilmente se demuestra que es igual a count. Si count es
multiplo de 8 copia esta cantidad de numeros:

8+(cociente(count/8)-1)*8

Que se demuestra es igual a count. Salvo en el caso particular
del count=0 en el que se copian 8 enteros ya que que el do
siempre se ejecuta independientemente de que la condición del
while no se cumpla de salida.

Saludos...

-- 
Manuel Constantino - MANOLO SOFT
Email: manolo@manolosoft.dhis.org