Newsgroup: it.comp.lang.c
Titolo: Indirizzamento ciclico (di nuovo)

Salve, ho una domanda di carattere generale.. non ne cessariamente per il 
solo linguaggio c..
si tratta del seguente: sto lavorando ad un algoritmo di sincronizzazione 
che lavora nel seguente modo: all'ingresso entrano sequenze di n short che 
vengono caricate in un buffer di lunghezza 2n: la prima sequenza viene 
scritta nella prima metà del buffer, la seconda nella seconda, la terza 
nella prima e via dicendo...
A questo punto comincia l'algoritmo che necessita la conoscenza di una 
sequenza di un numero di short superiore a n : ho risolto salvando gli short 
arrivati precedentemente in un buffer di memoria ausiliario in questo modo 
non rischio di cancellare con la nuova sequenza di short quelli ancora in 
uso dall'algoritmo di sincronizzazione.
Chiaramente tutto questo viene svolto ciclicamente con grande dispendo di 
risorse mentali per utilizzare gli argomenti con l'indice corretto nelle 
varie casistiche previste dalla sincronizzazione.
Il procedimento funziona e la sincronizzazione c'è SOLO che ora ho un nuovo 
problema:
infatti la demodulazione del segnale in ingresso sfrutta funzioni assembly 
che lavorano su vettori di n short lineari: mentre per come è implementata 
la sincronizzazione gli n short sarebbero quasi sempre distribuiti nel 
buffer parzialmente alla fine e parzialmente all'inizio rendendo inutile il 
tutto..
Non so come fare.. è una situazione molto complicata.. anche perchè i 
controlli in termini di if else ecc.. sono tanti..
Se non mi sono spiegato ecco il disegno:
|buffer 1 (n short)           | buffer 2 (n short)    |*|     |
|*| = qui cominciano gli n-k short della decodifica :
1) se k >0 non ho short a sufficienza per la decodifica di un pacchetto di 
short
2) essendovi o meno gli n short x la decodifica, comunque potrei avere che 
parte di essi si trovi all'inizio di buffer 1 !!
Come risolvo?
__________________________
Se la so, rispondo sempre (quasi) 

 ha scritto nel messaggio 
news:V81Je.51627$fm.33...@news4.tin.it...

Alla fine ho risolto nell'unico modo possibile penso:
una volta trovata la sincronizzazione posso avere 3 casi:
1) avere meno di un simbolo da processare
2) avere più di un simbolo da processare
3) avere esattamente un simbolo da processare
a seconda del numero di short che ho  scritto nel buffer:
_nel primo caso ricopio i simboli noti all'inizio del buffer e aggiungo con 
un fread quelli mancanti; quindi decodifico il primo simbolo e poi esco da 
questa situazione e mi riporto allo standard in cui copio il resto in buffer 
1 o 2 a seconda e decodifico su quelli
_nel secondo caso ho un primo simbolo completo e devo decodificarlo: se va a 
capo del buffer devo ricopiarlo mettendolo tutto sequenziale e lo 
decodifico, altrimenti lo decodifico cosi com'è  quindi prendo il segmento 
del simbolo successivo e se non ha spazio a sufficienza davanti lo traslo 
indietro e ci carico davanti gli short mancanti e decodifico, mentre se ha 
spazio ci carico solo gli short e decodifico!
_nel terzo caso, il + semplice ma più raro, posso direttamente 
decodificare.!
GS!!! 

Ah si... tutto questo mi costa sacrificio per un totale di una 30/40ina di 
if else e else if annidati in maniera contortissima uno dentro l'altro!!!