Problème de recompilation avec l'interface

Bonjour,

Voici mon problème: comme je voulais changer "beaucoup" mon code, j'ai enregistré mon "fichier1.f90" sous "fichier2.f90", et j'ai fait mes modifs dans le second fichier. Dans le premier source tout comme dans le second, j'utilise un module appelé interfaces1 (resp. interfaces2), où je mets toutes les interfaces de mes fonctions/sous-routines. Sauf que quand j'ai voulu compiler le fichier2, le compilateur reste bloqué sur le module interfaces1 (je le sais car, dans plusieurs fonctions, j'ai modifié le type d'un argument, et il me dit que le type ne correspond pas avec l'interface).

Est-il possible qu'il ne crée pas mon module d'interfaces?

J'espère que je vous ai donné toutes les infos nécessaires... merci d'avance!

bonjour,

je ne suis pas sûr d'avoir compris.

tu essaies de faire une compilation avec les fichiers suivants:

- fichier2.f90 (qui fait un use interfaces2 ?)
- interfaces2.f90 (qui contient les interfaces des subroutines et fonctions de fichier2 ?)

et tu obtiens un message d'erreur à la compilation qui te dit que le type et/ou le nombre d'arguments ne correspond pas ?

si c'est le cas, c'est difficile de répondre à la question sans avoir le message d'erreur que tu obtiens à la compilation.

ensuite, j'ai du mal à comprendre pourquoi tu as explicitement écrit des blocs interface dans ton module alors que l'un des gros avantages des modules en fortran90 est qu'ils génèrent automatiquement ces blocs interfaces.

si j'ai bien compris l'organisation de ton projet, je te conseillerai plutôt de faire quelque chose comme ceci:

- toutes tes fonctions et routines dans un fichier module (mod2) mod2.f90 par exemple.
- le programme principal (et uniquement lui) dans le fichier2.f90 qui fait un
use mod2.

et dans ce cas là, tu n'a plus à expliciter les interfaces et tu auras aussi la vérification des prototypes d'appel à la compilation.

Je vais essayer de faire ce que tu me dis. Mais dans ce cas (fichiers mod2.f90, fichier2.f90,...), il faut faire comment pour compiler ? Il y a une option de compilation ou il faut faire un makefile (la seconde solution me fait un peu peur...).

Encore merci pour ta réponse!

j'avais peur du makefile aussi au début, mais après on se rend compte que c'est vraiment très pratique :)

bien entendu tu peux faire sans (je mets gfortran parce que c'est mon compilateur):

Code:

---

1 2	gfortran -c mod2.f90 fichier2.f90 gfortran -o toto *.o

---

c'est tout :)

Les commandes que tu me proposes aboutissent aux mêmes erreurs. Il y en a 2, mais qui arrivent plusieurs fois:

-tm6.f90:87.44:

call donnees(nelem, nnoeu, nnint, x, elem, corr)
1
Error: Type mismatch in argument 'bord' at (1); passed INTEGER(4) to LOGICAL(4)

-tm6.f90:105.42:

call nabla(x, elem, q, nab_q, JFK, corr)
1
Error: More actual than formal arguments in procedure call at (1)

Et ces erreurs surviennent justement dans les fonctions auxquelles j'ai changé les arguments (pour la 1ère erreur, l'argument bord était logical, maintenant il est entier, pour la seconde, il y a un argument de plus). Je ne comprends pas pourquoi il "garde en mémoire" les fonctions tapées dans le fichier1.f90?

ok,

essaie en supprimant tous les fichiers .mod avant de faire la compilation.

Merci beaucoup kango. En bidouillant comme tu m'as dit, j'ai finalement vu, que dans 2-3 de mes fonctions, j'utilisais un

Code:

---

use interfaces1, only : f_cal

---

Et c'est entre autre de là que le problème provenait!

Encore merci beaucoup!

Citation:

---

Envoyé par kango

Code:

---

1 2	gfortran -c mod2.f90 fichier2.f90 gfortran -o toto *.o

---

---

Salut!
Je reviens sur ce sujet et plus particulièrement sur ton post. J'ai mis toutes mes fonctions dans le module "fonctions" (en n'oubliant pas le "contains" j'ai crû comprendre...) lui-même dans un fichier modfon.f90. J'ai enlevé toutes les interfaces de ces fonctions dans le fichier tm7.f90 et j'ai rajouté au début de "main": use fonctions. Ensuite j'ai tapé

Code:

---

1 2	gfortran -c modfon.f90 tm7.f90 gfortran -o tm7 tm7.o

---

La première ligne de code se passe bien (le fichier fonctions.mod est crée). La seconde m'affiche:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

tm7.o: In function `MAIN__': tm7.f90:(.text+0x181): undefined reference to `__fonctions_MOD_donnees' tm7.f90:(.text+0x176d): undefined reference to `__fonctions_MOD_detjfk' tm7.f90:(.text+0x1796): undefined reference to `__fonctions_MOD_matjfk' tm7.f90:(.text+0x1d21): undefined reference to `__fonctions_MOD_rigid' tm7.f90:(.text+0x1d4e): undefined reference to `__fonctions_MOD_membre_c' tm7.f90:(.text+0x1d66): undefined reference to `__fonctions_MOD_cholesky' tm7.f90:(.text+0x1da3): undefined reference to `__fonctions_MOD_nabla' tm7.f90:(.text+0x1de0): undefined reference to `__fonctions_MOD_nabla' tm7.f90:(.text+0x1e07): undefined reference to `__fonctions_MOD_construct_sol' tm7.f90:(.text+0x1e44): undefined reference to `__fonctions_MOD_nabla' tm7.f90:(.text+0x1eda): undefined reference to `__fonctions_MOD_eval_j' tm7.f90:(.text+0x1f9f): undefined reference to `__fonctions_MOD_mats' tm7.f90:(.text+0x1fc5): undefined reference to `__fonctions_MOD_memdroi' tm7.f90:(.text+0x1fe4): undefined reference to `__fonctions_MOD_solve_cholesky' tm7.f90:(.text+0x2021): undefined reference to `__fonctions_MOD_nabla' tm7.f90:(.text+0x206d): undefined reference to `__fonctions_MOD_minalphanr' tm7.f90:(.text+0x23d9): undefined reference to `__fonctions_MOD_nabla' tm7.f90:(.text+0x240a): undefined reference to `__fonctions_MOD_crit_arret' tm7.f90:(.text+0x2437): undefined reference to `__fonctions_MOD_crit_arret' tm7.f90:(.text+0x2555): undefined reference to `__fonctions_MOD_eval_j' collect2: ld returned 1 exit status

---

Qu'est-ce que je fais de faux?

Merci d'avance pour ta réponse!

bonjour,

tu as oublié de linker l'objet du module:

Code:

---

1 2	gfortran -c modfon.f90 tm7.f90 gfortran -o tm7 tm7.o

---

essaie plutôt:

Code:

---

1 2	gfortran -c modfon.f90 tm7.f90 gfortran -o tm7 tm7.o modfon.o

---

Merci kango, ca marche!
En fait, c'est parce que je ne comprends pas bien comment marche le compilateur (ce que représente un -c, un -o, un fichier .o,...) que je ne sais pas ce qu'il ne va pas... c'est pas si difficile que ça?

ok, pour faire simple, lorsque que l'on veut transformer des fichiers sources (texte) en executable, il y a au moins 2 étapes nécessaires:

- premièrement transformer le fichier source en un fichier objet (binaire) .o. Cette étape s'appelle la compilation. Cela correspond à la première ligne de compilation que je te donne. l'option -c signifie que l'on effectue que l'étape de compilation (et qu'on saute la deuxième étape)

- deuxièmement rassembler tous les fichiers objets (.o) dans un executable. Cette étape s'appelle l'édition des liens. Cela correspond à la deuxième ligne que je t'ai donnée. L'option -o est facultative, elle te sert juste à donner un nom particulier à l'exécutable. Durant cette étape, en fait ce n'est pas vraiment le compilateur qui travaille, c'est le linker (ld). Mais ton compilateur s'occupe de l'appeler avec les bonnes options.

Lors de l'étape de l'édition des liens, le linker essaie de résoudre toutes les références à des subroutines/fonctions:

- si la subroutine/fonction est dans le même .o pas de soucis
- si ce n'est pas le cas, le linker cherche les subroutines/fonctions dans le .o qui vient après dans la ligne de commande et ainsi de suite. du coup si l'objet a.o appelle des fonctions/subroutines définies dans l'objet b.o il faut toujours compiler dans cet ordre:

Code:

---

gfortran a.o b.o

---

c'est très sommaire, mais j'espère que ça t'aide à y voir un peu plus clair.

Merci beaucoup! Oui ça m'aide à y voir plus clair.
Je crois que je vais essayer de trouver de la doc sur ce genre de commande et aussi sur les makefiles. Plusieurs personnes m'ont dit qu'il ne fallait pas hésiter à faire plusieurs fichiers quand on programme (on m'a même conseiller un fichier par fonction). Du coup, s'y connaître un minimum s'impose...

Encore merci beaucoup pour tous tes conseils qui à chaque fois me sauvent!