I managed to make the code work using a non-type-bound function (instead of subroutine).
However, I need a type-bound subroutine:

Program Main

  use TypeDef_Module ,only: MyType

  use Second_Module  ,only: Action

  implicit none

  integer      :: iinp, iout

  type(MyType) :: TypVar

  iinp = 5

  call Action( TypVar, iinp, iout )

  write(*,*) iout

End Program
Module TypeDef_Module

  implicit none

  private

  public MyType, Fct

  Type :: MyType

  contains

    procedure ,nopass :: Fct

  End Type

  contains

  Function Fct ( iinp ) result(iout)

    integer ,intent(in)  :: iinp

    integer              :: iout

    iout = 2 * iinp

  End Function

End Module
Module Second_Module

  implicit none

  private

  public Action

  contains

  Subroutine Action ( TypVar, iinp, iout )

    use TypeDef_Module ,only: MyType, Fct

    implicit none

    type(MyType)         ,intent(in)  :: TypVar

    integer              ,intent(in)  :: iinp

    integer              ,intent(out) :: iout

    interface

      Function Fct_Interface ( iinp ) result(iout)

        integer ,intent(in)  :: iinp

        integer              :: iout

      End Function

    end interface

    procedure(Fct_Interface) ,pointer :: funct

!     funct => TypVar%Fct

!     associate	(TypFct => TypVar%Fct)

!       funct => TypFct

!     end associate

    funct => Fct

    iout = funct( iinp )

  End Subroutine

End Module

In the above code, Fct is exactly the same procedure than TypVar%Fct, except that is is not bound to a type.
If I comment line 50 and uncomment line 46, I get the following error:

second_module.f90(19): error #8191: The procedure target must be a procedure or a procedure pointer.   [FCT]

    funct => TypVar%Fct

--------------------^

second_module.f90(19): error #8180: The procedure pointer and the procedure target must have matching result types.   [FUNCT]

    funct => TypVar%Fct

----^

second_module.f90(19): error #8178: The procedure pointer and the procedure target must have matching arguments.

    funct => TypVar%Fct

----^

compilation aborted for second_module.f90 (code 1)

second_module.f90(19): error #8191: The procedure target must be a procedure or a procedure pointer.   [FCT]

    funct => TypVar%Fct

--------------------^

second_module.f90(19): error #8180: The procedure pointer and the procedure target must have matching result types.   [FUNCT]

    funct => TypVar%Fct

----^

second_module.f90(19): error #8178: The procedure pointer and the procedure target must have matching arguments.

    funct => TypVar%Fct

----^

compilation aborted for second_module.f90 (code 1)

I have also tried to used an associated block, without any success.

OK... bad news.

So, do you have any recommendations to solve my problem which is the following:

I want to solve a system of ODE equations using an external library such as DVODE or IODE (the Intel Ordinary Differential Equation Solver library). Both these libraries provides subroutine procedures (DVODE/DODESOL) which require procedure arguments for evaluating the ODE system Right-Hand-Side (RHS) and its associated jacobian (JAC).

I defined an abstract type called with an type-bound procedure which integrates the system according to a specific integration method defined at run-time. An ODE system is then created extending this type. Therefore, procedures for evaluating the RHS and the JAC can varie at rune-time. As a consequence, I need a way, in the integration procedure, to call the ODE solver procedure with different RHS and JAC procedure. Instead of:

call DODESOL ( ..., FCT_RHS, FCT_JAC, ... )

I need some thing like this:

call DODESOL ( ..., This%FCT_RHS, This%FCT_JAC, ... )

where "This" in the passeddummy argumenent corresponding to the system to be integrated.Unfortunately, this last formulation generate errors since the compiler think a variable is passed instead of a procedure leading th the following error

error #6635: This actual argument must be the name of a procedure and not a data object.

Thanks