Newsgroup: it.comp.lang.c
Titolo: Siete la mia unica salvezza

Sto lavorando alla mia tesi e parte del lavoro è il porting di un software
dal fortran al C. Un lavoro davvero noioso.
Ora, sarà la stanchezza (ho "portato" in C già più di 600 linee di codice),
ma sto impazzendo per questa porzione di codice.
Sarebbero graditi suggerimenti.
c -----------------------------------------------------------------
c Set up the relationship list xx.
c -----------------------------------------------------------------
    l=0
    do 130 i=1, n
            l=l+1
            xx(l)=i
            xptr(i)=l
            neg=0
            ptr=headp(i)
70       if (ptr.eq.0) goto 110
80                do 100 k=headc(clause(ptr)), headc(clause(ptr)+1)-1
                                index=iabs(lit(k))
                                do 90 j=xptr(i), l
                                            if (index.eq.xx(j)) goto 100
90                           continue
                                l=l+1
                                xx(l)=index
100             continue
                    if (neg.eq.1) then
                                ptr=nextm(ptr)
                                goto 120
                    endif
                    ptr=nextp(ptr)
                    goto 70
110     continue
            ptr=headm(i)
            neg=1
120     if (ptr.eq.0) goto 130
            goto 80
130 continue
xptr(n+1)=l+1

 dal fortran al C. Un lavoro davvero noioso.
non so se certe cose sono array o funzioni, comunque dovrebbe
essere qualcosa di questo tipo:
l=0;
for (i=1; i<=n; i++)
{
   l++;
   xx[l]=i;
   xptr[i]=l;
   neg=0;
   ptr=headp[i];
L070:
   if (ptr == 0) goto L110;
L080:
   for (k=headc[clause[ptr]]; k<=headc[clause[ptr]+1]-1; k++)
     {
       index=iabs(lit[k]);
       for (j=xptr[i]; j<=l; j++)
	if (index == xx[j]) goto L100;
       l++;
       xx[l]=index;
L100: ;
     }
   if (neg==1)
     {
       ptr=nextm[ptr];
       goto L120;
     }
   ptr=nextp[ptr];
   goto L070;
L110:
   ptr=headm[i];
   neg=1;
L120:
   if (ptr==0) continue;
   goto L080;
}
xptr[n+1]=l+1;
ciao,
g.

 ma sto impazzendo per questa porzione di codice.
...
Piu'  che la stanchezza, direi che il codice originale e' un museo degli 
orrori di programmazione non strutturata!
Io ho fatto il tentativo di modificare il codice originale per renderlo 
un po' piu' lineare. Ho usato uno strumento di ristrutturazione per 
codici Fortran (SPAG) che e'  free per uso accademico su linux
(per ulteriori info:
http://www.polyhedron.co.uk/pf/pflinux.html
 )
Supponendo che tutti i nomi con parentesi corrispondano ad array 
Fortran,  ottengo il codice seguente (ho dovuto inserire qualche linea 
prima e dopo il tuo frammento per ottenere un codice compilabile):
!*==pippo.spg  processed by SPAG 6.50Rc at 10:25 on  8 Jun 2005
       PROGRAM PIPPO
       IMPLICIT NONE
!*--PIPPO5
C*** Start of declarations inserted by SPAG
       REAL clause , headc , headm , headp , ptr , xptr , xx
       INTEGER i , index , j , k , lit , n , neg , nextm , nextp
C*** End of declarations inserted by SPAG
       DIMENSION xx(10) , xptr(10) , headp(10) , clause(10) , lit(10)
       DIMENSION nextm(10) , nextp(10) , headc(10) , headm(10)
       INTEGER l
       l = 0
       DO i = 1 , n
          l = l + 1
          xx(l) = i
          xptr(i) = l
          neg = 0
          ptr = headp(i)
  50      IF ( ptr.EQ.0 ) THEN
             ptr = headm(i)
             neg = 1
             GOTO 200
          ENDIF
  100     DO k = headc(clause(ptr)) , headc(clause(ptr)+1) - 1
             index = IABS(lit(k))
             DO j = xptr(i) , l
                IF ( index.EQ.xx(j) ) GOTO 150
             ENDDO
             l = l + 1
             xx(l) = index
  150     ENDDO
          IF ( neg.EQ.1 ) THEN
             ptr = nextm(ptr)
             GOTO 200
          ENDIF
          ptr = nextp(ptr)
          GOTO 50
  200     IF ( ptr.NE.0 ) GOTO 100
       ENDDO
       xptr(n+1) = l + 1
       END
Qualcosa e' migliorato. In relata' mi sembra possibile ristrutturare 
ulteriormente il codice, duplicando qualche riga in modo da eliminare i 
goto 50 e goto200 (ATTENZIONE,  queste sono modifiche che ho fatto a 
mano e dovresti controllare che la logica originale non sia stata cambiata):
       PROGRAM PIPPO
       IMPLICIT NONE
!*--PIPPO5
C*** Start of declarations inserted by SPAG
       REAL clause , headc , headm , headp , ptr , xptr , xx
       INTEGER i , index , j , k , lit , n , neg , nextm , nextp
C*** End of declarations inserted by SPAG
       DIMENSION xx(10) , xptr(10) , headp(10) , clause(10) , lit(10)
       DIMENSION nextm(10) , nextp(10) , headc(10) , headm(10)
       INTEGER l
       l = 0
       DO i = 1 , n
          l = l + 1
          xx(l) = i
          xptr(i) = l
          neg = 0
          ptr = headp(i)
          IF ( ptr.EQ.0 ) THEN
             ptr = headm(i)
             neg = 1
             IF ( ptr.NE.0 ) GOTO 100
          ENDIF
  100     DO k = headc(clause(ptr)) , headc(clause(ptr)+1) - 1
             index = IABS(lit(k))
             DO j = xptr(i) , l
                IF ( index.EQ.xx(j) ) GOTO 150
             ENDDO
             l = l + 1
             xx(l) = index
  150     ENDDO
          IF ( neg.EQ.1 ) THEN
             ptr = nextm(ptr)
             IF ( ptr.NE.0 ) GOTO 100
          ENDIF
          ptr = nextp(ptr)
          IF ( ptr.EQ.0 ) THEN
             ptr = headm(i)
             neg = 1
             IF ( ptr.NE.0 ) GOTO 100
          ENDIF
       ENDDO
       xptr(n+1) = l + 1
       END
Probabilmente si potrebbe fare ancora un po' di lavoro. Pero' adesso 
almeno ci sono solo due punti di arrivo di goto e il 150 e' innocuo.
A questo punto la traduzione in C dovrebbe essere molto piu' agevole 
sulla falsariga di quanto ti ha gia' suggerito Giovanni.
Giorgio

 ha scritto nel messaggio
news:d866of$3j2$1...@newsfeed.cineca.it...
[CUT]
GRazie davvero per l'attenzione ed il tempo che mi hai dedicato, cavolo hai
davvero riscritto il codice. Non pensavo che qualcuno lo avrebbe fatto.
La mia difficoltà risiede nella eliminazione dei salti incondizionati e nel
trasformare il codice in in codice strutturato (senza salti incondizionati).

 ha scritto nel messaggio
news:d86c72$1qu$1...@newsfeed.cineca.it...


 ha scritto nel messaggio
news:d86c72$1qu$1...@newsfeed.cineca.it...


 ha scritto nel messaggio
news:d86c72$1qu$1...@newsfeed.cineca.it...


 ha scritto nel messaggio
news:d86c72$1qu$1...@newsfeed.cineca.it...


 ha scritto nel messaggio
news:d86c72$1qu$1...@newsfeed.cineca.it...


 sacco di tempo.
...
Se parti da uno "spaghetti program" in Fortran,  con f2c ne otterrai la 
"spaghetti version in C" e,  in genere,  ancora meno leggibile dell' 
originale. Ed e' vero che "risparmi un sacco di tempo" ma solo dal punto 
di vista della conversione. Ne perdera' a vagonate chiunque debba 
mantenere quel codice.
Il vero problema del codice di partenza e' che era stato scritto da 
qualcuno che non aveva mai sentito  parlare di programmazione 
strutturata in qualsiasi linguaggio di programmazione.
Giorgio


Se pensavo che il tuo scopo era quello di ottenere codice strutturato,
sicuramente non ti avrei riscritto il programma.
Pensavo che il tuo scopo fosse quello di convertire un programma fortran
funzionante in un programma C funzionante (per quanto brutto).
Se il tempo stringe e' meglio un programma orrendo che funziona di
uno elegantissimo che non gira...
In ogni caso, se quello che vuoi e' la totale eliminazione dei goto,
penso che dovrai lavorarci parecchio. A quel punto la cosa piu'
sicura e' capire l'algoritmo e riscriverlo completamente. Pero'
quella e' una cosa che richiede un certo sforzo, non basta agire
"sintatticamente".
Al limite puoi aiutarti disegnando il diagramma a blocchi.
ciao,
g.