Fortran Compiler Terminologie: Dummy-Variablen und Attribute

Question

Kann mir jemand erklären, welcher Art von Abstraktion im Parser/Compiler eine Dummy-Variable oder Attribut entspricht?

 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 gibt Bezug genommen wird. Das Dummy-Attribut entspricht den Variablen, die an die Funktion übergeben werden (X und Y in Ihrem Fall). Die Parameteranweisung erwartet etwas Statisches, aber seit X ist was auch immer in die Funktion übergeben wird, es macht wirklich keinen Sinn. Die Parameteranweisung ist eine Möglichkeit, Konstanten einzurichten - sie hat nichts mit den Parametern einer Subroutine zu tun.

Wenn Sie den Fehler erhalten, dass C keine DUMMY Variable ist, dann bedeutet es, dass es nicht C in der Liste der Variablen ist zu finden, die in/aus der Funktion übergeben werden - Ihre Erklärung ist nur F(X, Y): nein C in Sicht. Obwohl Sie das Attribut DUMMY nicht explizit verwenden, haben Sie das Attribut INTENT(INOUT), was bedeutet, dass diese Variablen der Eingabe/Ausgabe von Unterprogrammen entsprechen.

zu bekommen, was Sie wollen, würden Sie eine Unterroutine, die wie etwas aussieht:

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 

Ich bin nicht ganz sicher, was Sie versuchen zu tun - Sie deklarieren eine pure Unterprogramm, was bedeutet, ein Unterprogramm ohne Nebeneffekte, aber Sie verwenden intent(inout) für Ihre Variablen, was bedeutet, dass X und Y im Laufe der Ausführung geändert werden können.

I als auch hinzufügen würde, die in einem Unterprogramm, eine Variable in der Deklarationsanweisung wie REAL :: C = 3.14E0 ergibt eine Variable mit einem impliziten save Attribute initialisiert. Wenn Sie möchten, dass es bei einem Anruf gespeichert wird, haben Sie das Richtige getan, indem Sie explizit das Attribut save hinzugefügt haben, um klarzustellen, dass Sie das tun.

Ich bin kein Parser/Compiler-Typ, aber ich denke, um Ihre Frage zu beantworten, bedeutet das dummy Attribut, dass Sie nur einen Zeiger bekommen - Sie müssen keinen Platz zuweisen, da die Variable verwendet Im Funktionsaufruf ist bereits Speicherplatz zugewiesen.

Answer 2

Das eigentliche Problem mit dem Anruf wird von Tim Whitcomb gut erklärt. Ich werde versuchen, die Begriffe genauer zu erklären.

Dummy-Argument ist ein Fortran-spezifischer Begriff. Andere Sprachen nennen formale Parameter oder ähnliches, d. H. Es ist das Objekt X und Y (in Ihrem Fall) und Hexe wird mit einem tatsächlichen Argument verbunden, wenn die Prozedur aufgerufen wird.

daher in:

subroutine s(i) 
    integer :: i 
end 

call s(1) 

die i ist ein Scheinargument der Subroutine s während des Ausdruck 1 das tatsächliche Argument ist die i zu dem Unterprogramm zu dem Dummy-Argumente übergeben wird.

Attribute sind eine Form der Angabe zusätzlicher Eigenschaften von Datenobjekten oder Prozeduren. Die Attribute können angegeben Aussagen werden:

real c 
intent(in) c 
optional c 

oder sie können in einer einzigen Erklärung angegeben werden:

real, intent(in), optional :: c 

diese Weise wird das Scheinargument c ist ein Standard-real mit Attributen intent(in) und optional.

Widersprüchliche Attribute sind Attribute, die nicht gleichzeitig für ein Objekt angegeben werden können. Ihr Beispiel mit intent(...) und parameter funktioniert gut. Diese sind inkompatibel, da die erste ein Dummy-Argument und die andere eine benannte Konstante angibt.