Terminologie du compilateur Fortran: Variables et attributs fictifs

Question

Quelqu'un peut-il m'expliquer quel genre d'abstraction dans l'analyseur/compilateur correspond une variable ou un attribut fictif?

 PURE SUBROUTINE F(X, Y) 
     IMPLICIT NONE 
     REAL, INTENT(INOUT) :: X, Y, C 
C  REAL :: A, B 
C  REAL, SAVE :: C = 3.14E0 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
     X = Y + 2 * SIN(Y) 
     END 

---

cetin@unique:~/lab/secret/tapenade$ gfortran -x f77 -c 1.f 
1.f:6.37: 

     PARAMETER (C = 3.14E0, X = 32, Y = X)       
            1 
Error: PARAMETER attribute conflicts with DUMMY attribute in 'x' at (1) 
1.f:3.38: 

     REAL, INTENT(INOUT) :: X, Y, C         
            1 
Error: Symbol at (1) is not a DUMMY variable 

---

cetin@unique:~/lab/secret/tapenade$ ifort -c 1.f 
1.f(3): error #6451: A dummy argument name is required in this context. [C] 
     REAL, INTENT(INOUT) :: X, Y, C 
-------------------------------------^ 
1.f(6): error #6406: Conflicting attributes or multiple declaration of name. [X] 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
-------------------------------^ 
1.f(6): error #6406: Conflicting attributes or multiple declaration of name. [Y] 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
---------------------------------------^ 
1.f(6): error #6592: This symbol must be a defined parameter, an enumerator, or an argument of an inquiry function that evaluates to a compile-time constant. [X] 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
-------------------------------------------^ 
compilation aborted for 1.f (code 1) 

Answer 1

Fortran passe par référence. L'attribut fictif correspond aux variables transmises à la fonction (X et Y dans votre cas). L'instruction de paramètre attend quelque chose de statique, mais puisque X est ce qui est passé dans la fonction, cela n'a vraiment aucun sens. L'instruction de paramètre est un moyen de configurer des constantes - cela n'a rien à voir avec les paramètres d'un sous-programme.

Lorsque vous obtenez l'erreur en disant que C est pas une variable DUMMY, alors, cela signifie qu'il est de ne pas trouver C dans la liste des variables qui seront transmises dans/hors de la fonction - votre déclaration est seulement F(X, Y): non C en vue. Bien que vous n'utilisiez pas explicitement l'attribut DUMMY, vous avez l'attribut INTENT(INOUT), ce qui signifie que ces variables correspondent aux entrées/sorties du sous-programme.

Pour obtenir ce que vous voulez, vous auriez un sous-programme qui ressemble à quelque chose comme:

subroutine F(X, Y) 
    implicit none 

    ! These are the dummy variables 
    real, intent(inout) :: X, Y 

    ! These are the variables in the scope of this subroutine 
    real     :: a, b 
    real, parameter, save :: c = 3.14E0 

    X = Y + 2*sin(Y) 
end subroutine F 

Je ne suis pas tout à fait sûr de ce que vous essayez de faire - vous déclarer un sous-programme pure, ce qui signifie un sous-programme sans effets secondaires, mais vous utilisez intent(inout) pour vos variables, ce qui signifie que X et Y peuvent être modifiés au cours de l'exécution.

Je rajouterais aussi bien qu'à l'intérieur d'un sous-programme, l'initialisation d'une variable dans sa déclaration de déclaration comme une variable REAL :: C = 3.14E0 cède avec un attribut implicite save. Cependant, si vous voulez que l'appel soit enregistré, vous avez fait la bonne chose en ajoutant explicitement l'attribut save pour indiquer clairement que c'est ce que vous faites. Je ne suis pas un type d'analyseur/compilateur, mais je pense que pour répondre à votre question, l'attribut dummy signifie que vous obtenez juste un pointeur - vous n'avez pas besoin d'allouer d'espace, puisque la variable utilisée dans l'appel de fonction, l'espace est déjà alloué.

Answer 2

Le problème réel avec l'appel est bien expliqué par Tim Whitcomb. Je vais essayer d'expliquer plus explicitement les termes.

L'argument factice est un terme spécifique à Fortran. C'est ce que d'autres langues appellent les paramètres formels ou similaire, c'est-à-dire l'objet qui est appelé X et Y (dans votre cas) et qui est associé à un argument réel lorsque la procédure est appelée.

Par conséquent, dans:

subroutine s(i) 
    integer :: i 
end 

call s(1) 

la i est un argument factice de la sous-routine s tandis que l'expression 1 est l'argument réel qui est transmis au sous-programme à l'argument factice i.

Les attributs sont une forme de spécification de propriétés supplémentaires d'objets de données ou de procédures. Les attributs peuvent être spécifiées à l'aide des déclarations:

real c 
intent(in) c 
optional c 

ou ils peuvent être spécifiés dans une seule déclaration:

real, intent(in), optional :: c 

De cette façon, l'argument factice c est un vrai par défaut avec des attributs intent(in) et optional.

Les attributs conflictuels sont des attributs qui ne peuvent pas être spécifiés pour un objet en même temps. Votre exemple avec intent(...) et parameter sert bien. Ceux-ci sont incompatibles car le premier implique un argument fictif et l'autre spécifie une constante nommée .