Преобразование кода Fortran 77 в C #

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

Есть ли кто-нибудь с опытом в такого рода вещах, кто мог бы дать мне какой-нибудь совет о том, как получить обзор этой подпрограммы? Существуют ли какие-либо инструменты для ускорения или упрощения этого типа конверсии?

По моему опыту, хороший способ сделать это - создать блок-схему кода на Фортране. Попробуйте разделить цели операторов GOTO на отдельные блоки и используйте диаграмму, чтобы попытаться понять код на высоком уровне.

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

В дополнение к тому, что написал Даниэль Б, я бы сказал следующее:

Во-первых, получите ваш код Fortran для работы с Fortran для DotNet. Не если вы «никуда не денетесь с перепрограммированием», но прежде чем пытаться перепрограммировать. Это будет маленький шаг, но в правильном направлении.

Затем напишите набор тестов на C #, который передает код на Фортране с любым вводимым им кодом и сохраняет результаты. Запустите тестовый набор один раз и сохраните вывод. Затем расширьте набор тестов, чтобы протестировать полученный результат в сравнении с сохраненным. Предполагая, что код Фортрана всегда выдает один и тот же вывод при подаче одного и того же ввода, тест, конечно, должен пройти успешно.

Затем, пока вы переписываете код в C #, вы будете запускать свой код в наборе тестов, и он будет сообщать вам, работает ли ваш код правильно или нет, имея в виду, выдает ли он точно такой же вывод, как и Fortran Код с тем же вводом. Без этого вы будете потеряны.

Я не согласен с @ SK-logic, вам НЕ ДОЛЖНО вообще использоваться gotos в вашем коде C #.

(Но, надеюсь, что после того, как вы запустите код на Фортране в DotNet, вы не увидите причин продолжать тратить время на преобразование фрагмента спагетти-кода в C #.)

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

Другой подход из того, что было предложением (не обязательно лучше, это просто еще один):

A - Подумайте о переписывании кода на C #, основываясь на знаниях и функциях бизнеса, используйте код на Фортране в качестве справочного материала.

B - Рассмотрите использование коммерческого инструмента, который выполняет конвертацию - Пример: DataTek

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

Если вышеупомянутое не сокращает это, ответьте на этот вопрос:

Нужно ли оптимизировать код или просто заставить его работать. Другими словами, какова коммерческая ценность того, чтобы тратить 500 часов на улучшение кода?

если в оптимизации нет значения, переведите код построчно, и все готово.

Если это все еще не хорошо, тогда:

0-Конвертировать код Фортран построчно в C # (или использовать Fortan CLR)

1-Сделайте быстрый тест, чтобы убедиться, что он работает

2-Используйте рефакторинг (коммерческие инструменты доступны), чтобы помочь вам написать код более оптимизированным способом.

Удачи.

Простой способ перекодировать материал с большим количеством gotos - нарисовать блок-схему и вывести строку прямо. Иногда программы F77 - это просто старые программы F66 или, что еще хуже, программы FII. У F66 не было конструкции if-then-else, поэтому gotos были необходимы. Все, что вам нужно сделать, это инвертировать условие, чтобы получить if-then.

У F66 тоже не было времени, а у F77. Это зависит от того, был ли кодер преобразован из F66 в F77 (как многие сегодня это C на C ++ или C ++ в C #), где они используют F77 как F66. Если вы можете определить паттерны в кодировке, их будет гораздо проще конвертировать.

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

Кроме того, будьте методичны , не торопитесь и используйте много бумаги, чтобы отследить функциональность.

Вот как я на самом деле пошел переводить код на C #. Поскольку .NET поддерживает операторы goto, я сначала взял весь код на Фортране и вставил его как есть в новый метод, а также столько методов, сколько было подпрограмм и подпрограмм на Фортране.

Компилятор обнаружил миллион ошибок, в основном из-за необъявленных переменных и неправильного форматирования операторов блока, которые я исправлял одну за другой. Мне также пришлось переписать некоторый специфичный для Фортрана код, такой как операторы ввода-вывода и тому подобное. Когда это было сделано, у меня была точная копия исходного кода.

Благодаря удобному форматированию Visual Studio логические блоки было намного проще идентифицировать, чем в исходном коде. И я мог бы начать распутывать заявления goto один за другим.

Исходя из этого опыта, я должен сказать, что в некоторых случаях операторы goto на самом деле ОЧЕНЬ полезны, чтобы избежать необходимости переписывать один и тот же код снова и снова, хотя во многих случаях того же можно достичь, используя методы и вызывая их повторно. ,

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

Общий подход к «декомпиляции» такого кода будет следующим:

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

Собственный бэкэнд LLVM C может предоставить вам первый черновик.

Без сомнения, лучший способ - это сначала переписать / реорганизовать код FORTRAN в более структурированный и логичный способ. Это заставит вас понять оригинальную логику, прежде чем пытаться перенести ее на C #.

Вот как я бы подошел к этому:

• Понимайте существующий код и, если необходимо, реорганизуйте его и даже переписывайте в FORTRAN, чтобы вы могли легко проверить его работоспособность.
• Перенесите измененный код на C #

Не тратьте свое время на автоматический конвертер кода, который в конечном итоге будет содержать тот же беспорядок в выражениях goto, что и в оригинальном FORTRAN, поскольку C # поддерживает gotos и метки, как и C.

В противном случае вы можете использовать операторы goto в C # .

Оператор goto передает управление программой непосредственно в помеченный оператор.

Обычно goto используется для передачи управления определенной метке переключения или метке по умолчанию в инструкции switch .

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

Чтобы преобразовать любой старый код FORTRAN в новый язык, кто-то должен пройти через некоторые основные шаги в вашем унаследованном коде (1) для проверки статического типа, преобразовать код в «IMPLICIT NONE» (2) преобразовать все усеченное общее в полное общее (3) Удалить эквивалентность (4) преобразовать общий в модуль FORTRAN 90

Затем вы можете попробовать конвертировать на другие языки.