gfortran bug regarding interface block with named END INTERFACE statements?

[Paul Van Delst <Paul dot vanDelst at noaa dot gov>]

Hello,

I'm having trouble compiling the code listed at the bottom of this email with gfortran. 
When I compile I get the error message(s):

 In file gfortran_test.f90:16
  END INTERFACE OPERATOR (.EqualTo.)
                                   1
Error: Expecting 'END INTERFACE OPERATOR (.compare_float.)' at (1)


This problem with recognizing the end interface statement flows on and produces a whole 
slew of further error messages, e.g.


 In file gfortran_test.f90:18
  INTEGER, PARAMETER :: Single = SELECTED_REAL_KIND(6)  ! Single precision
                                                                         1
Error: Unexpected data declaration statement in INTERFACE block at (1)
 In file gfortran_test.f90:19
  INTEGER, PARAMETER :: Double = SELECTED_REAL_KIND(15) ! Double precision
                                                                         1
Error: Unexpected data declaration statement in INTERFACE block at (1)
 In file gfortran_test.f90:21
CONTAINS
       1
Error: Unexpected CONTAINS statement in INTERFACE block at (1)


etc etc. Basically every line is flagged as an error because it's considered to be inside 
an interface block.

If I change the source code line
  END INTERFACE OPERATOR (.EqualTo.)
to simply
  END INTERFACE
the code compiles with gfortran also. However, I believe (but I'm not 100% sure) that the 
syntax of END INTERFACE OPERATOR (.EqualTo.) is standard Fortran95.

The gfortran version I'm using:
lnx:scratch : gfortran --version
GNU Fortran 95 (GCC) 4.1.0 20051025 (experimental)
Copyright (C) 2005 Free Software Foundation, Inc.


I've compiled and tested the offending code on linux using lf95, ifort, pgf95, and g95, 
and on IBM AIX and Sun Solaris systems with no compiler warnings.


Thanks for any information.

cheers,

paulv



------<<cut here>>------
MODULE Compare_Float_Numbers
  IMPLICIT NONE

  PRIVATE
  PUBLIC :: Compare_Float
  PUBLIC :: OPERATOR (.EqualTo.)

  INTERFACE Compare_Float
    MODULE PROCEDURE Compare_Float_Single
    MODULE PROCEDURE Compare_Float_Double
  END INTERFACE Compare_Float

  INTERFACE OPERATOR (.EqualTo.)
    MODULE PROCEDURE Is_Equal_To_Single
    MODULE PROCEDURE Is_Equal_To_Double
  END INTERFACE OPERATOR (.EqualTo.)

  INTEGER, PARAMETER :: Single = SELECTED_REAL_KIND(6)  ! Single precision
  INTEGER, PARAMETER :: Double = SELECTED_REAL_KIND(15) ! Double precision

CONTAINS

  ! -- Is Equal To
  ELEMENTAL FUNCTION Is_Equal_To_Single( x, y ) RESULT( Equal_To )
    REAL( Single ), INTENT( IN )  :: x, y
    LOGICAL :: Equal_To
    Equal_To = ABS( x - y ) < SPACING( MAX(ABS(x),ABS(y)) )
  END FUNCTION Is_Equal_To_Single

  ELEMENTAL FUNCTION Is_Equal_To_Double( x, y ) RESULT( Equal_To )
    REAL( Double ), INTENT( IN )  :: x, y
    LOGICAL :: Equal_To
    Equal_To = ABS( x - y ) < SPACING( MAX(ABS(x),ABS(y)) )
  END FUNCTION Is_Equal_To_Double

  ! -- General floating point comparison
  ELEMENTAL FUNCTION Compare_Float_Single( x, y, ulp ) RESULT( Compare )
    REAL( Single ),           INTENT( IN )  :: x
    REAL( Single ),           INTENT( IN )  :: y
    INTEGER,        OPTIONAL, INTENT( IN )  :: ulp
    LOGICAL :: Compare
    REAL( Single ) :: Rel
    Rel = 1.0_Single
    IF ( PRESENT( ulp ) ) THEN
      Rel = REAL( ABS(ulp), Single )
    END IF
    Compare = ABS( x - y ) < ( Rel * SPACING( MAX(ABS(x),ABS(y)) ) )
  END FUNCTION Compare_Float_Single

  ELEMENTAL FUNCTION Compare_Float_Double( x, y, ulp ) RESULT( Compare )
    REAL( Double ),           INTENT( IN )  :: x
    REAL( Double ),           INTENT( IN )  :: y
    INTEGER,        OPTIONAL, INTENT( IN )  :: ulp
    LOGICAL :: Compare
    REAL( Double ) :: Rel
    Rel = 1.0_Double
    IF ( PRESENT( ulp ) ) THEN
      Rel = REAL( ABS(ulp), Double )
    END IF
    Compare = ABS( x - y ) < ( Rel * SPACING( MAX(ABS(x),ABS(y)) ) )
  END FUNCTION Compare_Float_Double

END MODULE Compare_Float_Numbers
------<<cut here>>------


--
Paul van Delst
CIMSS @ NOAA/NCEP/EMC