Compilation/édition de liens avec modules blocs interfaces
bonjour,
j'ai un problème (évidemment).
J'ai créé un certains nombres de routines et fonctions en F90. Un sous-ensemble de ces routines et fonctions appartient à un même module.
Mais cet ensemble représentant une longue liste de lignes de code, j'ai mis chaque routine dans un fichier séparé et j'ai créé un fichier nomModule.f90 dans lequel on retrouve toutes les interfaces de mes fonctions. Tout ça dans un souci de lisibilité. Donc, en gros ça me permet de m'organiser en mettant tous les fichiers sources d'un même module dans un répertoire dédié, etc..
Bref..
j'ai un problème de compilation avec une routine de mon module qui fait appel à une fonction du même module. Il se trouve que cette fonction renvoie un tableau de valeurs. Je suis obligé de déclarer explicitement l'interface de ma fonction dans ma routine, alors qu'elles sont sensées appartenir au même module. A priori, ça risque de se reproduire avec d'autres modules à venir, et je trouve ça peu élégant.
maRoutine.f90 :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
subroutine maRoutine(x,y,z)
integer :: x,y
integer,dimension(:) :: z
!obligatoire sinon erreur de compilation
interface
function maFonction(x,y)
integer :: x,y
integer,dimension(x+y) :: z
end function
end interface
z = maFonction(x,y)
end subroutine |
maFonction.f90
Code:
1
2
3
4
5
6
7
8
9
|
function maFonction(x,y)
integer :: x,y
integer,dimension(x+y) :: maFonction
maFonction(i) = ...
end function |
monModule.f90
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
module monModule
interface
subroutine maRoutine(x,y,z)
integer :: x,y
integer,dimension(:) :: z
end subroutine
end interface
interface
function maFonction(x,y)
integer :: x,y
integer,dimension(x+y) :: z
end function
end interface
contains
...
end module |
et quand je compile, sans avoir l'interface de ma fonction explicitement déclarée dans ma fonction, j'obtiens ce message d'erreur :
Code:
1
2
|
Error: Function 'maFonction' at (1) has no implicit type |
y'a-t-il une astuce de compilation qui m'ai échappé ou bien une façon d'écrire les modules avec blocs interfaces pour que les fonctions et routines du module se connaissent entre elles sans avoir besoin de les redéclarer ? ou alors le problème d'une fonction qui retourne un tableau de valeurs est-il trop complexe pour F90 et doit donc forcément passer par une déclaration explicite d'interface à l'intérieur même de la routine ?
Merci de votre attention.
