Conversione del codice Fortran 77 in C #

Sto cercando di convertire un programma Fortan77 in C #. Ho una subroutine con circa 650 righe di codice e orribili dichiarazioni GOTO dappertutto. Ho molti problemi anche a cominciare a visualizzare il flusso della subroutine per capire cosa fa.

C'è qualcuno con esperienza in questo genere di cose che potrebbe darmi qualche consiglio su come ottenere una panoramica di questa subroutine? Ci sono alcuni strumenti disponibili per accelerare o facilitare questo tipo di conversione?

Nella mia esperienza, un buon modo di procedere è creare un diagramma di flusso del codice Fortran. Prova a separare le destinazioni delle istruzioni GOTO in blocchi separati e usa il diagramma per cercare di capire il codice ad alto livello.

Verifica se puoi sostituire logicamente i GOTO con loop o chiamate di funzione; se il diagramma risultante ha la forma di una struttura ad albero, è relativamente facile convertire in C # senza ricorrere a GOTO. Alla fine, però, dovrai comprendere il codice intimamente per poter conservare e utilizzare il risultato con sicurezza.

Oltre a ciò che Daniel B ha scritto sopra, direi quanto segue:

Innanzitutto, fai funzionare il tuo codice Fortran con Fortran per DotNet. Non se "non puoi arrivare da nessuna parte con la riprogrammazione", ma prima di tentare qualsiasi riprogrammazione. Sarà un piccolo passo, ma nella giusta direzione.

Quindi, scrivere una suite di test in C # che alimenta il codice Fortran con qualsiasi input sia stato fatto per sgranocchiare e memorizza l'output. Eseguire una volta la suite di test e salvare l'output. Quindi, estendere la suite di test per testare l'output prodotto sull'output salvato. Supponendo che il codice Fortran produca sempre lo stesso output quando viene alimentato lo stesso input, il test dovrebbe ovviamente avere successo.

Quindi, mentre riscrivi il codice in C #, eseguirai il codice nella suite di test e ti dirà se il tuo codice funziona correttamente o meno, il che significa che sta producendo esattamente lo stesso output di Fortran codice dato lo stesso input. Senza di essa, ti perderai.

Non sono d'accordo con la logica @ SK, NON dovresti usare alcuna goto nel tuo codice C #.

(Spero che una volta che avrai fatto funzionare il codice Fortran sotto DotNet non vedrai alcun motivo per continuare a perdere tempo a convertire un pezzo di codice spaghetti in C #.)

Il tuo compito è complicato. Devi davvero conoscere bene Fortran. Devi fare attenzione a come Fortran è simile / diverso ai calcoli e quali regole di troncamento e arrotondamento si applicano. Inoltre, devi stare attento ai tipi primitivi che significano in C # e Fortran.

Un altro approccio da quello che è stato suggerimento (non necessariamente uno migliore, è solo un altro):

A - Valuta di riscrivere il codice in C # in base alla conoscenza e alla funzione del business, usa il codice Fortran solo come riferimento

B -Considerare l'utilizzo di uno strumento commerciale che esegue il processo di conversione - Esempio: DataTek

Se la routine rappresenta una funzione standard o una funzione per la quale è possibile acquistare una dll pronta per l'uso (come l'integrazione numerica), utilizzare la funzione standard o il prodotto commerciale anziché la traduzione manuale e il problema è risolto.

Se quanto sopra non lo taglia, rispondi a questa domanda:

Devo ottimizzare il codice o semplicemente farlo funzionare. In altre parole, qual è il valore aziendale di spendere 500 ore per migliorare il codice?

se non c'è valore nell'ottimizzazione, traduci il codice riga per riga e il gioco è fatto.

Se questo non è ancora buono, allora:

0-Converti il ​​codice Fortran riga per riga in C # (o usa Fortan CLR)

1-Fai un test rapido assicurati che funzioni

2-Usa un re-factoring (sono disponibili strumenti commerciali) per aiutarti a scrivere il codice in modo più ottimizzato.

In bocca al lupo.

Un modo semplice per ricodificare le cose con molte goto è disegnare un diagramma di flusso e tirare la corda dritta. A volte, i programmi F77 sono solo vecchi programmi F66 o peggio ancora programmi FII. F66 non aveva un costrutto if-then-else, quindi erano necessarie le foto. Tutto quello che devi fare è invertire la condizione per ottenere un if-then.

F66 non ha avuto neanche un attimo ma F77 lo ha. Dipende dal fatto che il programmatore sia stato un convertitore da F66 a F77 (come molti oggi sono da C a C ++ o da C ++ a C #) dove usano F77 come F66. Se riesci a individuare i motivi, nella codifica, è molto più facile da convertire.

Prima di iniziare, crea una suite di test per testare il codice esistente. Sii molto accurato in quanto ciò contribuirà a far luce sul comportamento. È quindi possibile utilizzare questa suite per valutare l'efficacia della conversione.

Oltre a ciò, sii metodico , non affrettarti e usa molta carta per rintracciarne la funzionalità.

Ecco come ho effettivamente tradotto il codice in C #. Poiché .NET supporta le dichiarazioni goto, ho prima preso l'intero codice Fortran e incollato così com'è in un nuovo metodo, quindi, tutti i metodi che c'erano routine e subroutine Fortran.

Il compilatore ha prodotto un milione di errori, principalmente su variabili non dichiarate e formattazione errata dell'istruzione di blocco, che ho eliminato uno per uno. Ho anche dovuto riscrivere parte del codice specifico di Fortran, come le istruzioni I / O e cose del genere. Fatto ciò, ho avuto una replica esatta del codice originale.

Grazie alla piacevole formattazione di Visual Studio, i blocchi logici erano molto più facili da identificare rispetto al codice originale. E potrei iniziare a svelare le dichiarazioni goto una per una.

Da questa esperienza devo dire che ci sono alcuni casi in cui le istruzioni goto sono in realtà MOLTO utili per evitare di dover riscrivere lo stesso codice più e più volte, anche se in molti casi lo stesso può essere ottenuto usando metodi e chiamandoli ripetutamente .

Ho anche usato la versione gratuita di Silverfrost per compilare il codice originale e eseguire controlli regolari sul mio codice riformattato per garantire che la riformattazione non producesse errori.

Un approccio generico per "decompilare" un tale codice sarebbe il seguente:

• prima compilarlo in una forma di livello inferiore (ad esempio, LLVM)
• eseguire una trasformazione SSA su di essa (aiuterà a ripulire le variabili locali)
• dividere il flusso di controllo irriducibile (se presente)
• rilevare loop e if e sostituirli con i costrutti di alto livello adeguati

Il backend C di LLVM può fornirti una prima bozza.

Il modo migliore senza dubbio è innanzitutto riscrivere / riformattare il codice FORTRAN in un modo strutturato e logico migliore. Questo ti costringerà a comprendere la logica originale prima di provare a portarla su C #.

Ecco come lo approccerei:

• Comprendi il codice esistente e, se necessario, il refactor e persino riscriverlo in FORTRAN in modo da poter testare facilmente che funzioni.
• Porta il codice refactored su C #

Non perdere tempo con un convertitore di codice automatico che finirà con lo stesso pasticcio di dichiarazioni goto dell'originale FORTRAN poiché C # supporta goto ed etichette, proprio come fa C.

In caso contrario, puoi usare le istruzioni goto in C # .

L' istruzione goto trasferisce il controllo del programma direttamente a un'istruzione etichettata.

Un uso comune di goto è quello di trasferire il controllo a un'etichetta switch-case specifica o all'etichetta predefinita in un'istruzione switch .

L' istruzione goto è anche utile per uscire da loop profondamente nidificati ...

Per convertire qualsiasi vecchio codice FORTRAN in una nuova lingua qualcuno dovrebbe seguire alcuni passaggi di base nel codice legacy (1) per il controllo del tipo statico convertire il codice in "IMPLICIT NONE" (2) convertire tutti i comuni troncati in tutti i comuni (3) Rimuovi equivalenza (4) converti in comune a Modulo di FORTRAN 90

Quindi puoi provare a convertire in altre lingue.