Name: refactor-legacy-code
Author: OpenCourant

Prompt file imported from OpenCourant/OpenCourant (.github/prompts/refactor-legacy-code.prompt.md). Copyright stays with the author.

Refactor Legacy Code

Modernize legacy Fortran code to follow OpenRadioss standards while maintaining functionality.

Modernization Strategy

Phase 1: Assessment

Identify legacy constructs in the code
Check for COMMON blocks, GOTO statements, assumed-size arrays
Note dependencies and calling routines
Plan refactoring approach

Phase 2: Preparation

Ensure existing test coverage or create regression tests
Document current behavior
Set up comparison framework for validation

Phase 3: Refactoring

Apply transformations incrementally
Test after each change
Verify results match original

Legacy to Modern Transformations

1. Fixed-Form to Free-Form

Convert .F (fixed) to .F90 (free-form):

! OLD: Fixed-form (.F) with column restrictions
      SUBROUTINE OLD_SUB(A,B,N)
C     Comment with C in column 1
      INTEGER N
      DOUBLE PRECISION A(N),B(N)
      DO 10 I=1,N
        A(I)=A(I)+B(I)
   10 CONTINUE
      RETURN
      END

! NEW: Free-form (.F90)
      module old_sub_mod
        implicit none
      contains
        subroutine old_sub(a, b, n)
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Modules
! ----------------------------------------------------------------------------------------------------------------------
          use precision_mod, only : WP
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Implicit none
! ----------------------------------------------------------------------------------------------------------------------
          implicit none
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Arguments
! ----------------------------------------------------------------------------------------------------------------------
          integer,                 intent(in)    :: n
          real(kind=WP),           intent(inout) :: a(n)
          real(kind=WP),           intent(in)    :: b(n)
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Local variables
! ----------------------------------------------------------------------------------------------------------------------
          integer :: i
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Body
! ----------------------------------------------------------------------------------------------------------------------
          do i = 1, n
            a(i) = a(i) + b(i)
          end do
! ----------------------------------------------------------------------------------------------------------------------
        end subroutine old_sub
      end module old_sub_mod

use template/template.F90 as an example for indentation

2. Replace COMMON Blocks with Modules

! OLD: COMMON blocks
      COMMON /PARAMS/ TOL, MAXITER, CONV
      DOUBLE PRECISION TOL
      INTEGER MAXITER
      LOGICAL CONV

! NEW: Module with derived type
      module solver_params_mod
        use precision_mod, only : WP
        implicit none
        
        type :: solver_params_type
          real(kind=WP) :: tolerance
          integer :: max_iterations
          logical :: converged
        end type solver_params_type
        
        ! Module-level instance if needed
        type(solver_params_type) :: solver_params
        
      end module solver_params_mod

3. Eliminate GOTO Statements

! OLD: GOTO spaghetti
      IF (ERROR) GOTO 100
      CALL PROCESS()
      IF (DONE) GOTO 200
      GOTO 100
100   CONTINUE
      CALL CLEANUP()
200   CONTINUE
      RETURN

! NEW: Structured control flow
          if (error) then
            call cleanup()
            return
          end if

          call process()

          if (.not. done) then
            call cleanup()
            return
          end if

4. Replace Assumed-Size Arrays

! OLD: Assumed-size arrays
      SUBROUTINE PROCESS(ARRAY,N)
      INTEGER N
      DOUBLE PRECISION ARRAY(*)
      DO I=1,N
        ARRAY(I)=ARRAY(I)*2.D0
      ENDDO
      END

! NEW: Explicit-size arrays
      module process_mod
        implicit none
      contains
        subroutine process(array, n)
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Modules
! ----------------------------------------------------------------------------------------------------------------------
          use precision_mod, only : WP
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Implicit none
! ----------------------------------------------------------------------------------------------------------------------
          implicit none
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Arguments
! ----------------------------------------------------------------------------------------------------------------------
          integer,       intent(in)    :: n
          real(kind=WP), intent(inout) :: array(n)
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Local variables
! ----------------------------------------------------------------------------------------------------------------------
          integer :: i
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Body
! ----------------------------------------------------------------------------------------------------------------------
          do i = 1, n
            array(i) = array(i) * 2.0_WP
          end do
! ----------------------------------------------------------------------------------------------------------------------
        end subroutine process
      end module process_mod

5. Modernize Type Declarations

! OLD: Implicit typing and old declarations
      DOUBLE PRECISION A,B,C
      INTEGER*4 I,J,K
      REAL*8 X,Y,Z

! NEW: Explicit modern typing
          use precision_mod, only : WP
          implicit none
          real(kind=WP) :: a, b, c
          integer :: i, j, k
          real(kind=WP) :: x, y, z

6. Replace DO-CONTINUE with Modern DO

! OLD: Labeled DO-CONTINUE
      DO 10 I=1,N
        DO 20 J=1,M
          A(I,J)=B(I,J)+C(I,J)
   20   CONTINUE
   10 CONTINUE

! NEW: Modern DO-END DO
          do i = 1, n
            do j = 1, m
              a(i,j) = b(i,j) + c(i,j)
            end do
          end do

7. Modernize Intent Declarations

! OLD: No intent specifications
      SUBROUTINE CALC(INPUT,OUTPUT,WORK,N)
      INTEGER N
      DOUBLE PRECISION INPUT(N),OUTPUT(N),WORK(N)

! NEW: Explicit intent
      module calc_mod
        implicit none
      contains
        subroutine calc(input, output, work, n)
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Modules
! ----------------------------------------------------------------------------------------------------------------------
          use precision_mod, only : WP
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Implicit none
! ----------------------------------------------------------------------------------------------------------------------
          implicit none
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Arguments
! ----------------------------------------------------------------------------------------------------------------------
          integer,       intent(in)    :: n
          real(kind=WP), intent(in)    :: input(n)
          real(kind=WP), intent(out)   :: output(n)
          real(kind=WP), intent(inout) :: work(n)
! ----------------------------------------------------------------------------------------------------------------------
        end subroutine calc
      end module calc_mod

8. Replace EQUIVALENCE with Proper Data Structures

! OLD: EQUIVALENCE for memory overlay
      DOUBLE PRECISION A(100)
      DOUBLE PRECISION B(100)
      EQUIVALENCE (A(1),B(1))

! NEW: Use explicit copy or reshape as needed
          real(kind=WP) :: a(100)
          real(kind=WP) :: b(100)
          ! If shared data needed, use pointers or pass arguments
          b = a  ! Explicit copy if needed

9. Replace SAVE with Module Variables

! OLD: SAVE statement
      SUBROUTINE COUNTER()
      INTEGER COUNT
      SAVE COUNT
      DATA COUNT/0/
      COUNT=COUNT+1
      END

! NEW: Module variable
      module counter_mod
        implicit none
        integer, private :: count = 0
      contains
        
        subroutine increment_counter()
! ----------------------------------------------------------------------------------------------------------------------
!                                                   Body
! ----------------------------------------------------------------------------------------------------------------------
          count = count + 1
! ----------------------------------------------------------------------------------------------------------------------
        end subroutine increment_counter
        
      end module counter_mod

10. Modernize Preprocessor Usage

! OLD: MY_REAL preprocessor macro
#ifdef SINGLE_PRECISION
#define MY_REAL real(kind=4)
#else
#define MY_REAL double precision
#endif
      MY_REAL :: value

! NEW: Use WP from module
          use precision_mod, only : WP
          real(kind=WP) :: value

Step-by-Step Refactoring Process

Step 1: Create Wrapper Module

! Wrap existing subroutine in module
      module old_routine_mod
        implicit none
      contains
        
        ! Original routine goes here (initially unchanged)
        
      end module old_routine_mod

Step 2: Update Calling Code

! Update all call sites to use module
          use old_routine_mod, only : old_routine

Step 3: Modernize Implementation

Add proper intent declarations
Replace legacy constructs
Update variable declarations
Improve formatting and comments

Step 4: Compile and Test Thoroughly

# Compile starter with 5 threads
cd starter
./build_script.sh -arch=linux64_gf -mpi=ompi -nt=5

# Compile engine with 5 threads
cd ../engine
./build_script.sh -arch=linux64_gf -mpi=ompi -nt=5

# Run QA tests
cd ../qa-tests/scripts
./or_qa_script ./../../exec/engine_linux64_gf

# Compare outputs if needed
diff old_results.out new_results.out

Common Pitfalls

⚠️ Precision Changes

Be careful changing DOUBLE PRECISION to real(kind=WP)
Verify literal constants have proper kind: 1.0_WP not 1.0D0
Check for mixed precision operations

⚠️ Array Indexing

Verify loop bounds are correct after changes
Check for off-by-one errors
Ensure array sizes are consistent

⚠️ Implicit Behavior

Old code may rely on implicit typing
Add implicit none carefully and declare all variables
Watch for variables starting with I-N (implicitly integer)

⚠️ Side Effects

COMMON blocks may have hidden dependencies
SAVE variables maintain state between calls
Be careful preserving intended behavior

Validation Checklist

After refactoring:

Code compiles without errors or warnings
All regression tests pass
Results match original within tolerance
No performance degradation
Follows OpenRadioss coding standards
Comments and documentation updated
Module dependencies clear and minimal
No legacy constructs remain

Tools to Help

Automated Formatting:

# Use fprettify or similar tools for initial formatting
fprettify -i 2 --strict-indent --case 1 1 1 1 file.F90

Static Analysis:

# Check for common issues
gfortran -Wall -Wextra -pedantic -fsyntax-only file.F90

Code Review:

Review changes with experienced team member
Check against template structure
Verify compliance with coding guidelines

When NOT to Refactor

Consider leaving code as-is if:

Code is stable and rarely modified
Extensive testing would be required
Performance-critical section needs optimization first
Dependencies are too complex to untangle safely
Resources for thorough validation not available

Always weigh benefits against risks!

Install refactor-legacy-code and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

# Refactor Legacy Code Modernize legacy Fortran code to follow OpenRadioss standards while maintaining functionality. ## Modernization Strategy ### Phase 1: Assessment 1. Identify legacy constructs in the code 2. Check for COMMON blocks, GOTO statements, assumed-size arrays 3. Note dependencies and calling routines 4. Plan refactoring approach ### Phase 2: Preparation 1. Ensure existing test coverage or create regression tests 2. Document current behavior 3. Set up comparison framework for validation ### Phase 3: Refactoring 1. Apply transformations incrementally 2. Test after each change 3. Verify results match original ## Legacy to Modern Transformations ### 1. Fixed-Form to Free-Form **Convert .F (fixed) to .F90 (free-form):** ```fortran ! OLD: Fixed-form (.F) with column restrictions SUBROUTINE OLD_SUB(A,B,N) C Comment with C in column 1 INTEGER N DOUBLE PRECISION A(N),B(N) DO 10 I=1,N A(I)=A(I)+B(I) 10 CONTINUE RETURN END ! NEW: Free-form (.F90) module old_sub_mod implicit none contains subroutine old_sub(a, b, n) ! ---------------------------------------------------------------------------------------------------------------------- ! Modules ! ---------------------------------------------------------------------------------------------------------------------- use precision_mod, only : WP ! ---------------------------------------------------------------------------------------------------------------------- ! Implicit none ! ---------------------------------------------------------------------------------------------------------------------- implicit none ! ---------------------------------------------------------------------------------------------------------------------- ! Arguments ! ---------------------------------------------------------------------------------------------------------------------- integer, intent(in) :: n real(kind=WP), intent(inout) :: a(n) real(kind=WP), intent(in) :: b(n) ! ---------------------------------------------------------------------------------------------------------------------- ! Local variables ! ---------------------------------------------------------------------------------------------------------------------- integer :: i ! ---------------------------------------------------------------------------------------------------------------------- ! Body ! ---------------------------------------------------------------------------------------------------------------------- do i = 1, n a(i) = a(i) + b(i) end do ! ---------------------------------------------------------------------------------------------------------------------- end subroutine old_sub end module old_sub_mod ``` use template/template.F90 as an example for indentation ### 2. Replace COMMON Blocks with Modules ```fortran ! OLD: COMMON blocks COMMON /PARAMS/ TOL, MAXITER, CONV DOUBLE PRECISION TOL INTEGER MAXITER LOGICAL CONV ! NEW: Module with derived type module solver_params_mod use precision_mod, only : WP implicit none type :: solver_params_type real(kind=WP) :: tolerance integer :: max_iterations logical :: converged end type solver_params_type ! Module-level instance if needed type(solver_params_type) :: solver_params end module solver_params_mod ``` ### 3. Eliminate GOTO Statements ```fortran ! OLD: GOTO spaghetti IF (ERROR) GOTO 100 CALL PROCESS() IF (DONE) GOTO 200 GOTO 100 100 CONTINUE CALL CLEANUP() 200 CONTINUE RETURN ! NEW: Structured control flow if (error) then call cleanup() return end if call process() if (.not. done) then call cleanup() return end if ``` ### 4. Replace Assumed-Size Arrays ```fortran ! OLD: Assumed-size arrays SUBROUTINE PROCESS(ARRAY,N) INTEGER N DOUBLE PRECISION ARRAY(*) DO I=1,N ARRAY(I)=ARRAY(I)*2.D0 ENDDO END ! NEW: Explicit-size arrays module process_mod implicit none contains subroutine process(array, n) ! ---------------------------------------------------------------------------------------------------------------------- ! Modules ! ---------------------------------------------------------------------------------------------------------------------- use precision_mod, only : WP ! ---------------------------------------------------------------------------------------------------------------------- ! Implicit none ! ---------------------------------------------------------------------------------------------------------------------- implicit none ! ---------------------------------------------------------------------------------------------------------------------- ! Arguments ! ---------------------------------------------------------------------------------------------------------------------- integer, intent(in) :: n real(kind=WP), intent(inout) :: array(n) ! ---------------------------------------------------------------------------------------------------------------------- ! Local variables ! ---------------------------------------------------------------------------------------------------------------------- integer :: i ! ---------------------------------------------------------------------------------------------------------------------- ! Body ! ---------------------------------------------------------------------------------------------------------------------- do i = 1, n array(i) = array(i) * 2.0_WP end do ! ---------------------------------------------------------------------------------------------------------------------- end subroutine process end module process_mod ``` ### 5. Modernize Type Declarations ```fortran ! OLD: Implicit typing and old declarations DOUBLE PRECISION A,B,C INTEGER*4 I,J,K REAL*8 X,Y,Z ! NEW: Explicit modern typing use precision_mod, only : WP implicit none real(kind=WP) :: a, b, c integer :: i, j, k real(kind=WP) :: x, y, z ``` ### 6. Replace DO-CONTINUE with Modern DO ```fortran ! OLD: Labeled DO-CONTINUE DO 10 I=1,N DO 20 J=1,M A(I,J)=B(I,J)+C(I,J) 20 CONTINUE 10 CONTINUE ! NEW: Modern DO-END DO do i = 1, n do j = 1, m a(i,j) = b(i,j) + c(i,j) end do end do ``` ### 7. Modernize Intent Declarations ```fortran ! OLD: No intent specifications SUBROUTINE CALC(INPUT,OUTPUT,WORK,N) INTEGER N DOUBLE PRECISION INPUT(N),OUTPUT(N),WORK(N) ! NEW: Explicit intent module calc_mod implicit none contains subroutine calc(input, output, work, n) ! ---------------------------------------------------------------------------------------------------------------------- ! Modules ! ---------------------------------------------------------------------------------------------------------------------- use precision_mod, only : WP ! ---------------------------------------------------------------------------------------------------------------------- ! Implicit none ! ---------------------------------------------------------------------------------------------------------------------- implicit none ! ---------------------------------------------------------------------------------------------------------------------- ! Arguments ! ---------------------------------------------------------------------------------------------------------------------- integer, intent(in) :: n real(kind=WP), intent(in) :: input(n) real(kind=WP), intent(out) :: output(n) real(kind=WP), intent(inout) :: work(n) ! ---------------------------------------------------------------------------------------------------------------------- end subroutine calc end module calc_mod ``` ### 8. Replace EQUIVALENCE with Proper Data Structures ```fortran ! OLD: EQUIVALENCE for memory overlay DOUBLE PRECISION A(100) DOUBLE PRECISION B(100) EQUIVALENCE (A(1),B(1)) ! NEW: Use explicit copy or reshape as needed real(kind=WP) :: a(100) real(kind=WP) :: b(100) ! If shared data needed, use pointers or pass arguments b = a ! Explicit copy if needed ``` ### 9. Replace SAVE with Module Variables ```fortran ! OLD: SAVE statement SUBROUTINE COUNTER() INTEGER COUNT SAVE COUNT DATA COUNT/0/ COUNT=COUNT+1 END ! NEW: Module variable module counter_mod implicit none integer, private :: count = 0 contains subroutine increment_counter() ! ---------------------------------------------------------------------------------------------------------------------- ! Body ! ---------------------------------------------------------------------------------------------------------------------- count = count + 1 ! ---------------------------------------------------------------------------------------------------------------------- end subroutine increment_counter end module counter_mod ``` ### 10. Modernize Preprocessor Usage ```fortran ! OLD: MY_REAL preprocessor macro #ifdef SINGLE_PRECISION #define MY_REAL real(kind=4) #else #define MY_REAL double precision #endif MY_REAL :: value ! NEW: Use WP from module use precision_mod, only : WP real(kind=WP) :: value ``` ## Step-by-Step Refactoring Process ### Step 1: Create Wrapper Module ```fortran ! Wrap existing subroutine in module module old_routine_mod implicit none contains ! Original routine goes here (initially unchanged) end module old_routine_mod ``` ### Step 2: Update Calling Code ```fortran ! Update all call sites to use module use old_routine_mod, only : old_routine ``` ### Step 3: Modernize Implementation - Add proper intent declarations - Replace legacy constructs - Update variable declarations - Improve formatting and comments ### Step 4: Compile and Test Thoroughly ```bash # Compile starter with 5 threads cd starter ./build_script.sh -arch=linux64_gf -mpi=ompi -nt=5 # Compile engine with 5 threads cd ../engine ./build_script.sh -arch=linux64_gf -mpi=ompi -nt=5 # Run QA tests cd ../qa-tests/scripts ./or_qa_script ./../../exec/engine_linux64_gf # Compare outputs if needed diff old_results.out new_results.out ``` ## Common Pitfalls **⚠️ Precision Changes** - Be careful changing DOUBLE PRECISION to real(kind=WP) - Verify literal constants have proper kind: `1.0_WP` not `1.0D0` - Check for mixed precision operations **⚠️ Array Indexing** - Verify loop bounds are correct after changes - Check for off-by-one errors - Ensure array sizes are consistent **⚠️ Implicit Behavior** - Old code may rely on implicit typing - Add `implicit none` carefully and declare all variables - Watch for variables starting with I-N (implicitly integer) **⚠️ Side Effects** - COMMON blocks may have hidden dependencies - SAVE variables maintain state between calls - Be careful preserving intended behavior ## Validation Checklist After refactoring: - [ ] Code compiles without errors or warnings - [ ] All regression tests pass - [ ] Results match original within tolerance - [ ] No performance degradation - [ ] Follows OpenRadioss coding standards - [ ] Comments and documentation updated - [ ] Module dependencies clear and minimal - [ ] No legacy constructs remain ## Tools to Help **Automated Formatting:** ```bash # Use fprettify or similar tools for initial formatting fprettify -i 2 --strict-indent --case 1 1 1 1 file.F90 ``` **Static Analysis:** ```bash # Check for common issues gfortran -Wall -Wextra -pedantic -fsyntax-only file.F90 ``` **Code Review:** - Review changes with experienced team member - Check against template structure - Verify compliance with coding guidelines ## When NOT to Refactor Consider leaving code as-is if: - Code is stable and rarely modified - Extensive testing would be required - Performance-critical section needs optimization first - Dependencies are too complex to untangle safely - Resources for thorough validation not available Always weigh benefits against risks!

{ "prompt": "# Refactor Legacy Code\n\nModernize legacy Fortran code to follow OpenRadioss standards while maintaining functionality.\n\n## Modernization Strategy\n\n### Phase 1: Assessment\n1. Identify legacy constructs in the code\n2. Check for COMMON blocks, GOTO statements, assumed-size arrays\n3. Note dependencies and calling routines\n4. Plan refactoring approach\n\n### Phase 2: Preparation\n1. Ensure existing test coverage or create regression tests\n2. Document current behavior\n3. Set up comparison framework for validation\n\n### Phase 3: Refactoring\n1. Apply transformations incrementally\n2. Test after each change\n3. Verify results match original\n\n## Legacy to Modern Transformations\n\n### 1. Fixed-Form to Free-Form\n\n**Convert .F (fixed) to .F90 (free-form):**\n\n```fortran\n! OLD: Fixed-form (.F) with column restrictions\n SUBROUTINE OLD_SUB(A,B,N)\nC Comment with C in column 1\n INTEGER N\n DOUBLE PRECISION A(N),B(N)\n DO 10 I=1,N\n A(I)=A(I)+B(I)\n 10 CONTINUE\n RETURN\n END\n\n! NEW: Free-form (.F90)\n module old_sub_mod\n implicit none\n contains\n subroutine old_sub(a, b, n)\n! ----------------------------------------------------------------------------------------------------------------------\n! Modules\n! ----------------------------------------------------------------------------------------------------------------------\n use precision_mod, only : WP\n! ----------------------------------------------------------------------------------------------------------------------\n! Implicit none\n! ----------------------------------------------------------------------------------------------------------------------\n implicit none\n! ----------------------------------------------------------------------------------------------------------------------\n! Arguments\n! ----------------------------------------------------------------------------------------------------------------------\n integer, intent(in) :: n\n real(kind=WP), intent(inout) :: a(n)\n real(kind=WP), intent(in) :: b(n)\n! ----------------------------------------------------------------------------------------------------------------------\n! Local variables\n! ----------------------------------------------------------------------------------------------------------------------\n integer :: i\n! ----------------------------------------------------------------------------------------------------------------------\n! Body\n! ----------------------------------------------------------------------------------------------------------------------\n do i = 1, n\n a(i) = a(i) + b(i)\n end do\n! ----------------------------------------------------------------------------------------------------------------------\n end subroutine old_sub\n end module old_sub_mod\n```\nuse template/template.F90 as an example for indentation\n\n### 2. Replace COMMON Blocks with Modules\n\n```fortran\n! OLD: COMMON blocks\n COMMON /PARAMS/ TOL, MAXITER, CONV\n DOUBLE PRECISION TOL\n INTEGER MAXITER\n LOGICAL CONV\n\n! NEW: Module with derived type\n module solver_params_mod\n use precision_mod, only : WP\n implicit none\n \n type :: solver_params_type\n real(kind=WP) :: tolerance\n integer :: max_iterations\n logical :: converged\n end type solver_params_type\n \n ! Module-level instance if needed\n type(solver_params_type) :: solver_params\n \n end module solver_params_mod\n```\n\n### 3. Eliminate GOTO Statements\n\n```fortran\n! OLD: GOTO spaghetti\n IF (ERROR) GOTO 100\n CALL PROCESS()\n IF (DONE) GOTO 200\n GOTO 100\n100 CONTINUE\n CALL CLEANUP()\n200 CONTINUE\n RETURN\n\n! NEW: Structured control flow\n if (error) then\n call cleanup()\n return\n end if\n\n call process()\n\n if (.not. done) then\n call cleanup()\n return\n end if\n```\n\n### 4. Replace Assumed-Size Arrays\n\n```fortran\n! OLD: Assumed-size arrays\n SUBROUTINE PROCESS(ARRAY,N)\n INTEGER N\n DOUBLE PRECISION ARRAY(*)\n DO I=1,N\n ARRAY(I)=ARRAY(I)*2.D0\n ENDDO\n END\n\n! NEW: Explicit-size arrays\n module process_mod\n implicit none\n contains\n subroutine process(array, n)\n! ----------------------------------------------------------------------------------------------------------------------\n! Modules\n! ----------------------------------------------------------------------------------------------------------------------\n use precision_mod, only : WP\n! ----------------------------------------------------------------------------------------------------------------------\n! Implicit none\n! ----------------------------------------------------------------------------------------------------------------------\n implicit none\n! ----------------------------------------------------------------------------------------------------------------------\n! Arguments\n! ----------------------------------------------------------------------------------------------------------------------\n integer, intent(in) :: n\n real(kind=WP), intent(inout) :: array(n)\n! ----------------------------------------------------------------------------------------------------------------------\n! Local variables\n! ----------------------------------------------------------------------------------------------------------------------\n integer :: i\n! ----------------------------------------------------------------------------------------------------------------------\n! Body\n! ----------------------------------------------------------------------------------------------------------------------\n do i = 1, n\n array(i) = array(i) * 2.0_WP\n end do\n! ----------------------------------------------------------------------------------------------------------------------\n end subroutine process\n end module process_mod\n```\n\n### 5. Modernize Type Declarations\n\n```fortran\n! OLD: Implicit typing and old declarations\n DOUBLE PRECISION A,B,C\n INTEGER*4 I,J,K\n REAL*8 X,Y,Z\n\n! NEW: Explicit modern typing\n use precision_mod, only : WP\n implicit none\n real(kind=WP) :: a, b, c\n integer :: i, j, k\n real(kind=WP) :: x, y, z\n```\n\n### 6. Replace DO-CONTINUE with Modern DO\n\n```fortran\n! OLD: Labeled DO-CONTINUE\n DO 10 I=1,N\n DO 20 J=1,M\n A(I,J)=B(I,J)+C(I,J)\n 20 CONTINUE\n 10 CONTINUE\n\n! NEW: Modern DO-END DO\n do i = 1, n\n do j = 1, m\n a(i,j) = b(i,j) + c(i,j)\n end do\n end do\n```\n\n### 7. Modernize Intent Declarations\n\n```fortran\n! OLD: No intent specifications\n SUBROUTINE CALC(INPUT,OUTPUT,WORK,N)\n INTEGER N\n DOUBLE PRECISION INPUT(N),OUTPUT(N),WORK(N)\n\n! NEW: Explicit intent\n module calc_mod\n implicit none\n contains\n subroutine calc(input, output, work, n)\n! ----------------------------------------------------------------------------------------------------------------------\n! Modules\n! ----------------------------------------------------------------------------------------------------------------------\n use precision_mod, only : WP\n! ----------------------------------------------------------------------------------------------------------------------\n! Implicit none\n! ----------------------------------------------------------------------------------------------------------------------\n implicit none\n! ----------------------------------------------------------------------------------------------------------------------\n! Arguments\n! ----------------------------------------------------------------------------------------------------------------------\n integer, intent(in) :: n\n real(kind=WP), intent(in) :: input(n)\n real(kind=WP), intent(out) :: output(n)\n real(kind=WP), intent(inout) :: work(n)\n! ----------------------------------------------------------------------------------------------------------------------\n end subroutine calc\n end module calc_mod\n```\n\n### 8. Replace EQUIVALENCE with Proper Data Structures\n\n```fortran\n! OLD: EQUIVALENCE for memory overlay\n DOUBLE PRECISION A(100)\n DOUBLE PRECISION B(100)\n EQUIVALENCE (A(1),B(1))\n\n! NEW: Use explicit copy or reshape as needed\n real(kind=WP) :: a(100)\n real(kind=WP) :: b(100)\n ! If shared data needed, use pointers or pass arguments\n b = a ! Explicit copy if needed\n```\n\n### 9. Replace SAVE with Module Variables\n\n```fortran\n! OLD: SAVE statement\n SUBROUTINE COUNTER()\n INTEGER COUNT\n SAVE COUNT\n DATA COUNT/0/\n COUNT=COUNT+1\n END\n\n! NEW: Module variable\n module counter_mod\n implicit none\n integer, private :: count = 0\n contains\n \n subroutine increment_counter()\n! ----------------------------------------------------------------------------------------------------------------------\n! Body\n! ----------------------------------------------------------------------------------------------------------------------\n count = count + 1\n! ----------------------------------------------------------------------------------------------------------------------\n end subroutine increment_counter\n \n end module counter_mod\n```\n\n### 10. Modernize Preprocessor Usage\n\n```fortran\n! OLD: MY_REAL preprocessor macro\n#ifdef SINGLE_PRECISION\n#define MY_REAL real(kind=4)\n#else\n#define MY_REAL double precision\n#endif\n MY_REAL :: value\n\n! NEW: Use WP from module\n use precision_mod, only : WP\n real(kind=WP) :: value\n```\n\n## Step-by-Step Refactoring Process\n\n### Step 1: Create Wrapper Module\n```fortran\n! Wrap existing subroutine in module\n module old_routine_mod\n implicit none\n contains\n \n ! Original routine goes here (initially unchanged)\n \n end module old_routine_mod\n```\n\n### Step 2: Update Calling Code\n```fortran\n! Update all call sites to use module\n use old_routine_mod, only : old_routine\n```\n\n### Step 3: Modernize Implementation\n- Add proper intent declarations\n- Replace legacy constructs\n- Update variable declarations\n- Improve formatting and comments\n\n### Step 4: Compile and Test Thoroughly\n```bash\n# Compile starter with 5 threads\ncd starter\n./build_script.sh -arch=linux64_gf -mpi=ompi -nt=5\n\n# Compile engine with 5 threads\ncd ../engine\n./build_script.sh -arch=linux64_gf -mpi=ompi -nt=5\n\n# Run QA tests\ncd ../qa-tests/scripts\n./or_qa_script ./../../exec/engine_linux64_gf\n\n# Compare outputs if needed\ndiff old_results.out new_results.out\n```\n\n## Common Pitfalls\n\n**⚠️ Precision Changes**\n- Be careful changing DOUBLE PRECISION to real(kind=WP)\n- Verify literal constants have proper kind: `1.0_WP` not `1.0D0`\n- Check for mixed precision operations\n\n**⚠️ Array Indexing**\n- Verify loop bounds are correct after changes\n- Check for off-by-one errors\n- Ensure array sizes are consistent\n\n**⚠️ Implicit Behavior**\n- Old code may rely on implicit typing\n- Add `implicit none` carefully and declare all variables\n- Watch for variables starting with I-N (implicitly integer)\n\n**⚠️ Side Effects**\n- COMMON blocks may have hidden dependencies\n- SAVE variables maintain state between calls\n- Be careful preserving intended behavior\n\n## Validation Checklist\n\nAfter refactoring:\n- [ ] Code compiles without errors or warnings\n- [ ] All regression tests pass\n- [ ] Results match original within tolerance\n- [ ] No performance degradation\n- [ ] Follows OpenRadioss coding standards\n- [ ] Comments and documentation updated\n- [ ] Module dependencies clear and minimal\n- [ ] No legacy constructs remain\n\n## Tools to Help\n\n**Automated Formatting:**\n```bash\n# Use fprettify or similar tools for initial formatting\nfprettify -i 2 --strict-indent --case 1 1 1 1 file.F90\n```\n\n**Static Analysis:**\n```bash\n# Check for common issues\ngfortran -Wall -Wextra -pedantic -fsyntax-only file.F90\n```\n\n**Code Review:**\n- Review changes with experienced team member\n- Check against template structure\n- Verify compliance with coding guidelines\n\n## When NOT to Refactor\n\nConsider leaving code as-is if:\n- Code is stable and rarely modified\n- Extensive testing would be required\n- Performance-critical section needs optimization first\n- Dependencies are too complex to untangle safely\n- Resources for thorough validation not available\n\nAlways weigh benefits against risks!", "variables": [], "notes": "Refactor legacy Fortran code to modern F90 standards", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/OpenCourant/OpenCourant", "path": ".github/prompts/refactor-legacy-code.prompt.md", "ref": "36ecc625ff98e9979d0a687926b67390bc5554ec", "url": "https://github.com/OpenCourant/OpenCourant/blob/36ecc625ff98e9979d0a687926b67390bc5554ec/.github/prompts/refactor-legacy-code.prompt.md", "key": "OpenCourant/OpenCourant/.github/prompts/refactor-legacy-code.prompt.md" } }, "model_hints": [ "Claude Sonnet 4.5" ] }

refactor-legacy-code

About