    ! This file is an example to test the syntax highlighting file F.xml
    ! (for fortran 90 and F)

    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    !                      THIS IS AN EXAMPLE OF A MODULE                          !
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    module module_example

      ! use 'implicit none' when you want all variables to be declared
      implicit none

    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    ! PUBLICS AND PRIVATES

      ! In fortran 90 you can define your own operator
      public :: operator(.norm.)
      public :: operator(+) ! <-- you can also overload the usual operators
      public :: factorial
      public :: example_fn

      private :: point3d_add
      private :: point3d_norm

    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    ! USER-DEFINED TYPES...

      ! This is a definition to use in declarations of real variables,
      ! parameters, etc.
      integer, parameter, public :: kr = selected_real_kind(10)

      ! This is a user-defined type
      type, public :: point3d
        real(kind=kr) :: x, y, z
      end type point3d

      ! This type is useless: it is only an example of type definition!
      type, public :: example_type
        complex(kind=kr)            :: c ! <-- a complex number (two reals of kind kr)!
        real, dimension(-10:10)     :: & ! <-- this line does not end here!
          r1, r2 ! <-- this is the final part of the previous line
        real, pointer, dimension(:) :: pointer_to_array_of_real
        real, dimension(:), pointer :: array_of_pointer_to_real
      end type example_type

    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    ! INTERFACES...

      ! Interface for the norm of a 3-D vector
      interface operator(.norm.)
        module procedure point3d_norm
      end interface

      ! Interface for the operator '+'
      interface operator(+)
        module procedure point3d_add
      end interface

    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    ! SOME DECLARATIONS...

      ! A real number can be declared with the following line:
      real(kind=kr) :: real_var1
      ! But if you are not interested on the precision of floating point numbers,
      ! you can use simply:
      real :: real_var2

      ! An array can be declared in two ways:
      real(kind=kr), dimension(1:10, -4:5), private :: a, b, c
      real(kind=kr), private :: d(1:10, -4:5)

      ! This is a string with fixed lenght
      character(len=10) :: str_var

      ! This is an allocatable array, which can be a target of a pointer
      type(example_type), private, dimension(:), allocatable, target :: &
       many_examples

    ! Fortran 90 hasn't got its own preprocessor, it uses the C preprocessor!
    #ifdef XXX
    c <-- this is a comment in the old fortran 77 style (fixed form)
    c This is a free form file, so we shouldn't use this kind of comments!
    c But fortran 90 still understands fixed form, when parsing sources with
    c the *.f extension.
     c ! <-- this 'c' shouldn't be highlighted as a comment!
    #endif

    contains

      ! The sum of two points
      pure function point3d_add(a, b) result(rs)
        type(point3d) :: rs
        type(point3d), intent(in) :: a, b
        rs%x = a%x + b%x
        rs%y = a%y + b%y
        rs%z = a%z + b%z
      end function point3d_add

      ! The norm of a point
      pure function point3d_norm(a) result(rs)
        real(kind=kr) :: rs
        type(point3d), intent(in) :: a
        rs = sqrt(a%x * a%x + a%y * a%y + a%z * a%z)
      end function point3d_norm

      ! A simple recursive function
      recursive function factorial(i) result (rs)
        integer :: rs
        integer, intent(in) :: i
        if ( i <= 1 ) then
          rs = 1
        else
          rs = i * factorial(i - 1)
        end if
      end function factorial

      ! This is a useless function
      subroutine example_fn(int_arg, real_arg, str_arg)
        integer, intent(in) :: int_arg
        real(kind=kr), intent(out) :: real_arg
        character(len=*), intent(in) :: str_arg

        type(example_type), pointer :: p
        integer :: n, i, j
        logical :: flag

        flag = .true. ! .true. is not an operator!
        if ( flag .and. flag ) then ! .and. is a pre-defined operator
          print *, "blabla"
        end if

        ! Examples of inquiry functions: allocated, lbound, ubound.
        if ( .not. allocated(many_examples) ) then
          allocate( many_examples(10) )
        end if
        print *, "Lower bound = ", lbound(many_examples, 1)
        print *, "Upper bound = ", ubound(many_examples, 1)

        p => many_examples(5) ! <-- p is a pointer

        ! A strange way to calculate i*i: add the first i odd numbers
        i = 6
        j = 0
        do n = 1, i
          j = j + (2*n - 1)
        end do
        print *, "i*i = ", i*i, j

        real_arg = real(j) ! <-- here the highlighting is not very good:
        ! it is unable to distinguish between this and a definition like:
        !  real(kind=kr) :: a
        deallocate( many_examples )
      end subroutine example_fn

    end module module_example

    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    !                         THIS IS THE MAIN PROGRAM                             !
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    program example
      use module_example

      ! this is another example of use of the 'implicit' keyword
      implicit double precision (a-h,o-z)

      real(kind=kr) :: var_out

      type(point3d) :: &
       a = point3d(0.0_kr, 1.0_kr, 2.0_kr), &
       b = point3d(4.0_kr, 5.0_kr, 6.0_kr)

      print *, "a + b = ", .norm. (a + b)
      print *, "factorial of 5 = ", factorial(5)

      call example_fn(1, var_out, "hello!")

    end program example