Перетворення коду Fortran 77 в C #

Я намагаюся перетворити програму Fortan77 в C #. У мене є підпрограма з приблизно 650 рядками коду та жахливими заявами GOTO всюди. У мене виникають багато проблем, навіть починаючи візуалізувати потік підпрограми, щоб зрозуміти, що це робить.

Чи є хтось із досвідом подібних речей, хто міг би дати мені поради щодо того, як отримати огляд цієї підпрограми? Чи є деякі інструменти для прискорення або полегшення такого типу конверсій?

На мій досвід, хороший спосіб зробити це - створити схему потоку коду Фортран. Спробуйте розділити цілі операторів GOTO на окремі блоки та скористайтеся діаграмою, щоб спробувати зрозуміти код на високому рівні.

Подивіться, чи можете ви логічно замінити GOTO на петлі або виклики функцій; якщо отримана діаграма має форму дерева-структури, її відносно легко перетворити на C #, не вдаючись до GOTO. Зрештою, вам потрібно буде глибоко зрозуміти код, щоб мати змогу впевнено підтримувати та використовувати результат.

Окрім того, що Даніель Б писав вище, я б сказав наступне:

По-перше, отримайте свій код Fortran для роботи з Fortran для DotNet. Не якщо ви "не можете дістатися нікуди з перепрограмуванням", але перед тим, як спробувати перепрограмувати. Це буде невеликий крок, але в правильному напрямку.

Потім напишіть тестовий набір в C #, який подає код Fortran, з будь-яким вкладом, який він робив для того, щоб переглядати, і зберігає вихід. Запустіть тестовий набір один раз і збережіть результат. Потім продовжте тестовий набір, щоб перевірити отриманий вихід на збережений вихід. Якщо припустити, що код Fortran завжди видає однаковий вихід, коли подається один і той же вхід, тест, звичайно, повинен бути успішним.

Потім, поки ви переписуєте код у C #, ви запускаєте свій код під тестовим набором, і він повідомляє вам, чи працює ваш код належним чином чи ні, тобто, чи виробляє він такий самий вихід, як і Fortran код з таким же входом. Без нього ви загубитесь.

Я не погоджуюся з @ SK-логікою, вам НЕ потрібно взагалі використовувати жодних gotos у своєму C # коді.

(Сподіваємось, що після того, як ви змусили код Fortran працювати під DotNet, ви не побачите причин продовжувати витрачати свій час на перетворення шматка коду спагетті в C #.)

Ваше завдання складне. Вам дійсно потрібно добре знати Фортран. Ви повинні бути обережними щодо того, як подібні / різні Fortran роблять розрахунки та які правила урізання та округлення застосовуються. Крім того, вам слід бути обережними щодо значення примітивних типів у C # та Fortran.

Ще один підхід із запропонованих пропозицій (не обов'язково кращий, це просто інший):

A - Подумайте про повторне написання коду в C # на основі ділових знань та функції, використовуйте код Fortran лише як орієнтир

B -прочитайте, використовуючи комерційний інструмент, який виконує завдання перетворення - Приклад: DataTek

Якщо рутина являє собою стандартну функцію або функцію, для якої ви можете придбати готовий dll (наприклад, числова інтеграція), використовуйте стандартну функцію або комерційний продукт замість ручного перекладу, і ваша проблема вирішена.

Якщо вищезгадане не вирішує, відповідь на це питання:

Чи потрібно мені оптимізувати код або просто змусити його працювати. Іншими словами, яка цінність бізнесу - витратити 500 годин на покращення коду?

якщо немає значення в оптимізації, перекладіть код рядок за рядком, і ви закінчите.

Якщо це все ще не добре, то:

0-Перетворіть рядок коду Fortran за рядком в C # (або використовуйте Fortan CLR)

1 - Зробіть швидкий тест, переконайтеся, що він працює

2-Використовуйте повторний факторинг (доступні комерційні інструменти), щоб допомогти вам написати код більш оптимізованим способом.

Удачі.

Простий спосіб перекодувати речі з великою кількістю готосів - намалювати блок-схему та витягнути рядок прямо. Іноді програми F77 - це лише старі програми F66 або ще гірші програми FII. У F66 не було конструкції «тоді ще», тому «готос» був необхідний. Все, що вам потрібно зробити, це перевернути умову, щоб отримати "if-then".

У F66 теж не було часу, але у F77 є. Це залежить від того, чи був кодер перетвореним з F66 в F77 (як багато сьогодні є C до C ++ або C ++ до C #), де вони використовують F77, як F66. Якщо ви можете помітити шаблони, в кодуванні їх набагато простіше перетворити.

Перш ніж розпочати роботу, складіть тестовий набір, щоб перевірити існуючий код. Будьте дуже ретельними, оскільки це допоможе пролити світло на поведінку. Потім ви можете використовувати цей набір для оцінки ефективності конверсії.

Крім того, будьте методичні , не поспішайте та використовуйте багато паперу, щоб відстежити функціональність.

Ось як я насправді пішов про переклад коду в C #. Оскільки .NET підтримує goto-заяви, я спершу взяв увесь код Fortran і вставив його як новий метод, ну і стільки методів, скільки були підпрограми та підпрограми Fortran.

Компілятор створив мільйон помилок, здебільшого про недекларовані змінні та неправильне форматування тверджень блоків, які я очистив по черзі. Я також повинен був переписати деякі специфічні для Fortran коди, як-от оператори вводу-виводу та подібні речі. Коли це було зроблено, у мене була точна копія оригінального коду.

Завдяки приємному форматуванню Visual Studio логічні блоки було набагато простіше визначити, ніж у вихідному коді. І я міг би почати розгадувати твердження goto по черзі.

З цього досвіду я мушу сказати, що є деякі випадки, коли оператори goto насправді ДУЖЕ корисні, щоб уникнути необхідності переписувати один і той же код знову і знову, хоча у багатьох випадках те ж саме можна досягти, використовуючи методи та повторно викликаючи їх .

Я також використовував безкоштовну версію Silverfrost для складання оригінального коду та регулярних перевірок мого переформатованого коду, щоб переконатися, що переформатування не призвело до помилок.

Загальним підходом до "декомпіляції" такого коду буде такий:

• спочатку компілюйте його у форму нижчого рівня (наприклад, LLVM)
• виконайте перетворення SSA на ньому (це допоможе очистити локальні змінні)
• розділити невідводимий потік управління (якщо такий є)
• виявити петлі та ifs та замінити їх належними конструкціями високого рівня

Власний сервер C LLVM може надати вам перший проект.

Найкращий спосіб, без сумніву, - спочатку переписати / перефабрикувати код FORTRAN краще структурованим та логічним способом. Це змусить вас зрозуміти оригінальну логіку перед тим, як спробувати перенести її на C #.

Ось як я підійшов би до цього:

• Зрозумійте наявний код і, якщо потрібно, рефактор і навіть перепишіть його у FORTRAN, щоб ви могли легко перевірити, що він працює.
• Перенесіть код, що реконструюється, на C #

Не витрачайте час на автоматичний перетворювач коду, який просто закінчиться тим самим безладом заяв goto, що й оригінальний FORTRAN, оскільки C # підтримує gotos та мітки, як і C.

Якщо нічого іншого не вдалося, ви можете використовувати goto-оператори в C # .

Оператор goto передає програмне управління безпосередньо в оператор з міткою.

Загальне використання goto полягає в передачі керування на конкретну мітку регістру комутатора або мітку за замовчуванням в операторі комутатора .

Оператор goto також корисний для виходу з глибоко вкладених циклів ...

Щоб конвертувати будь-який старий код FORTRAN на нову мову, хтось повинен пройти кілька основних етапів у вашому спадковому коді (1) для перевірки статичного типу перетворити код у "IMPLICIT NONE" (2) перетворити всі усічені загальні у повністю загальні (3) Видалити еквівалентність (4) перетворення загального в модуль FORTRAN 90

Потім ви можете спробувати перетворити на інші мови.