Fortran 中是否存在异常处理？

Question

Is there any exception handling structure in Fortran, just like in Python?

try:
    print "Hello World"
except:
    print "This is an error message!"

If it does not exist, what would be the easiest way to handle exceptions?

Answer 1

Exceptions as such do not exist in Fortran, so no, there is no Exception handling.

But you can do something similar to Exception handling using Standard Fortran - there's even a paper on it Arjen Markus, "Exception handling in Fortran" .

The most common notation is to use an (integer) return variable indicating the error code:

subroutine do_something(stat)
    integer :: stat
    print "Hello World"
    stat = 0
end subroutine

and in the main program do

call do_something(stat)
if (stat /= 0) print *,"This is an error message!"

---

There are other ways described in the paper such as defining a dedicated derived type for exceptions that is capable of also storing an error message. The example mentioned there that gets closest to an Exception is using alternate returns for subroutines (not possible with functions, though):

subroutine do_something(stat, *)
    integer :: stat
    !...

    ! Some error occurred
    if (error) return 1
end subroutine

and in the main program do

try: block
    call do_something(stat, *100)
    exit try ! Exit the try block in case of normal execution
100 continue ! Jump here in case of an error
    print *,"This is an error message!"
end block try

Please note that the block construct requires a compiler compliant with Fortran 2008.

I've never seen something like this out there, though :)

Answer 2

There are proposals (see Steve Lionel's comment below) to add exception handling to the next Fortran standard. See here for example: Exception handling - BCS Fortran Specialist Group

This has apparently a long history in Fortran (again see Steve's second comment below)

Answer 3

Considering that a great deal of try-except use cases are for I/O handling, you should know that all FORTRAN I/O functions have an ERR specifier which points to a line label in the case an error happens. For example:

C2345678
      READ( UNIT=5, FMT=10, ERR=30, IOSTAT=N ) X
   10 FORMAT(I5) 

      WRITE( UNIT=6, FMT=20, ERR=30, IOSTAT=N ) X
   20 FORMAT(I5)

   30 WRITE( *, * ) 'I/O error # ', N, ', on 1'

of course one could replace the WRITE executable with any other expression to achieve some form of except functionality.

PS source of examples here and here .

Answer 4

Although this is not a proper "exception handling" I found practically useful the following subroutine

SUBROUTINE RAISE_EXCEPTION(message)
  INTEGER i
  CHARACTER(LEN=*) message
  PRINT *,message
  i=1
  i=1/(i-i)
ENDSUBROUTINE

that can be called when an error condition occurs, eg

IF (var<0) CALL RAISE_EXCEPTION('Error: var should be positive!')

If the code is compiled with gfortran -ffpe-trap=zero and -fbacktrace options ( -fpe0 with ifort), the code will be stopped (because of the intentional division by zero in the subroutine) and a call stack will be printed. Moreover, if you are debugging the code, the process won't be killed (even if the execution is halted) so you can explore variables, call stack etc. from inside the debugger.

Answer 5

You could implement exception handling in Fortran 2003 without resorting to the alternate return statements in Arjen Markus's solution. The idea is to use the final procedure of a type that stores the exceptions.

A basic implementation is

module exception_mod
   implicit none

   type exception_stack_t
      ! should contain a list of raised exceptions, 
      ! but keep it simple for this example
      logical :: raised = .false.
   contains
      final :: error_if_uncaught
   end type

contains
   subroutine raise(e)
      ! should take an exception as a dummy argument, and add it to the stack.
      type(exception_stack_t), intent(out) :: e

      e%raised = .true.
   end subroutine

   logical function catch(e) result(was_raised)
      ! should catch a particular type of exception that is passed to this procedure
      type(exception_stack_t), intent(inout) :: e

      was_raised = e%raised
      e%raised = .false.
   end function

   subroutine error_if_uncaught(this)
      type(exception_stack_t), intent(in) :: this

      if (this%raised) error stop "EXCEPTION was not caught"
   end subroutine
end module

and an example of raising an exception is

   subroutine my_sqrt(x,sqrt_x,e)
      real, intent(in) :: x
      real, intent(out) :: sqrt_x
      type(exception_stack_t), optional, allocatable, intent(inout) :: e

      type(exception_stack_t), allocatable :: my_e

      if (x < 0) then
         allocate(my_e)
         call raise(my_e)
         ! should push exception `my_e` to the stack `e`
         if (present(e)) call move_alloc(my_e, e)
         return
      endif

      sqrt_x = sqrt(x)
   end subroutine

Now you can call this in several ways, assuming

real :: sqrt_x
type(exception_stack_t), allocatable :: e

1. Regular call:

    call my_sqrt(-1.0,sqrt_x)

   prints "EXCEPTION was not caught" , due to the my_e local variable in my_sqrt .

2. Calling without catching the exception:

    call my_sqrt(-1.0,sqrt_x,e)

   gives "EXCEPTION was not caught" once e goes out of scope.

3. Equivalent of a try-except block:

    call my_sqrt(-1.0,sqrt_x,e) if (catch(e)) then print "(a)", "ValueError for 'my_sqrt', but I'm continuing." else print "(a,f0.10)", "sqrt = ", sqrt_x endif

   which gives "ValueError for 'my_sqrt', but I'm continuing."

This is different from using an error-indicating integer, because

1. the caller does not have to remember to check the error status (the final procedure will do that);

2. exception_stack_t could store a list of raised exceptions, and it could be passed along procedures that call each other. Exceptions can be caught at any level.

You could also define a whole hierarchy of exception types.

In principle it would be possible to create the same exception architecture as in Python, though it would be used with a very different syntax.