Statique (Lexicale) Délimitation vs Dynamique de Portée (Pseudo-code)

Avec statique (lexicale) délimitation, la structure du code source du programme détermine les variables que vous faites allusion. Avec dynamique de portée, l'état d'exécution de la pile du programme détermine quelle variable on se réfère. Cela est probablement très mal le concept, depuis le fond, chaque langage de programmation largement utilisé de nos jours (à l'exception peut-être emacs lisp) utilise une portée lexicale, qui tend à être beaucoup plus facile pour les humains et les outils d'analyse de raisonner sur.

Considérer ce beaucoup plus simple programme d'exemple (il est écrit dans le pseudo-code de la syntaxe):

program a() {
  x: integer; //"x1" in discussions below
  x = 1;

  procedure b() {
    x = 2; //<-- which "x" do we write to?
  }

  procedure c() {
    x: integer; //"x2" in discussions below
    b();
  }

  c();
  print x;
}

Le programme et le compilateur se référer à ces deux variables comme x, mais j'ai marqué leur x1 et x2 pour faciliter la discussion ci-dessous.

Avec une portée lexicale, on détermine, au moment de la compilation x nous nous référons à la statique, lexical de la structure du code source du programme. Le plus profond de la définition de x dans la portée lorsque définition b est x1, et l'écriture en question décide de x1, et c'est là que x = 2 écrit, nous avons donc l'impression 2 lors de l'exécution de ce programme.

Avec dynamique de la portée des projets, nous avons une pile de définitions de variables suivies à l'exécution -- alors, qui x nous écrire à dépend de ce qui est exactement dans le champ d'application et a été défini de façon dynamique à l' runtime. Début d'exécuter a pousse x => x1 sur la pile, l'appel de c pousse x => x2 sur la pile, et puis quand on arrive à b, le sommet de la pile est x => x2, et ainsi de nous écrire en x2. Cela laisse x1 intacte, et nous avons donc l'impression 1 à la fin du programme.

En outre, considérez ce qui est légèrement différent du programme:

program a() {
  x: integer; //"x1" in discussions below
  x = 1;

  procedure b() {
    x = 2; //<-- which "x" do we write to?
  }

  procedure c() {
    x: integer; //"x2" in discussions below
    b();
  }

  c();
  b();
}

Note b est appelé à deux reprises: la première fois via c, la deuxième fois directement. Avec une portée lexicale, l'explication ci-dessus n'est pas changé, et nous l'avons écrit dans x1 les deux fois. Cependant, avec la dynamique de la portée, il dépend de la façon dont x est lié à l'exécution. La première fois que nous appelons b, nous écrire en x2 comme expliqué ci-dessus, mais la deuxième fois, nous écrire en x1, puisque c'est ce qui est en haut de la pile! (x => x2 est sauté quand c retourne.)

Donc, ici, c'est votre professeur de code, annoté avec laquelle exact de la variable est utilisée sur lequel écrire avec une portée lexicale. Écrit que l'extrémité imprimé à la fin du programme sont marqués avec un *:

program A()
{
    x, y, z: integer; //x1, y1, z1

    procedure B()
    {
        y: integer; //y2
        y=0; //y2 = 0
        x=z+1; //x1 = z1 + 1 = 12 + 1 = 13*
        z=y+2; //z1 = y2 + 2 = 0 + 2 = 2*
    }

    procedure C()
    {
        z: integer; //z2

        procedure D()
        {
            x: integer;  //x2
            x = z + 1; //x2 = z2 + 1 = 5 + 1 = 6
            y = x + 1; //y1 = x2 + 1 = 6 + 1 = 7*
            call B();
        }

        z = 5; //z2 = 5
        call D();
    }

    x = 10; //x1 = 10
    y = 11; //y1 = 11
    z = 12; //z1 = 12
    call C();
    print x, y, z; //x1, y1, z1
}

Et ici, il est avec dynamique de portée. Remarque le seulement changements sont en B, et à l'emplacement de la * tags:

program A()
{
    x, y, z: integer; //x1, y1, z1

    procedure B()
    {
        y: integer; //y2
        y=0; //y2 = 0
        x=z+1; //x2 = z2 + 1 = 5 + 1 = 6
        z=y+2; //z2 = y2 + 2 = 0 + 2 = 2
    }

    procedure C()
    {
        z: integer; //z2

        procedure D()
        {
            x: integer;  //x2
            x = z + 1; //x2 = z2 + 1 = 5 + 1 = 6
            y = x + 1; //y1 = x2 + 1 = 6 + 1 = 7*
            call B();
        }

        z = 5; //z2 = 5
        call D();
    }

    x = 10; //x1 = 10*
    y = 11; //y1 = 11
    z = 12; //z1 = 12*
    call C();
    print x, y, z;
}

Le point crucial est que le lexique graphique ressemble à ceci:

B <- A -> C -> D

alors que le graphe d'appel ressemble à ceci:

     A -> C -> D -> B

La seule différence est que la lignée B a. Dans le lexique de l'image, B est défini directement dans le champ d'application de l'Une (la portée mondiale). Dans la dynamique de l'image, la pile à B dispose déjà D sur le dessus de C, puis A.

Cette différence représente la façon dont les mots-clés x et z sont résolus dans B. Lexicalement, ils sont identifiés par A.x et A.z, mais de façon dynamique, ils sont identifiés par D.x et (depuis pas D.z existe) avec C.z.

def B:
    B.y = 0
    x = z + 1
    z = y + 2
def C:
    def D:
        D.x = z + 1
        y = D.x + 1
        call B
    C.z = 5
    call D
A.x, A.y, A.z = 10, 11, 12
call C
print A.x, A.y, A.z

Ci-dessus, j'ai essayé de représenter votre code plus clairement. Notez que D mute A.y selon les deux méthodes de résolution de nom, alors que B mute A.x et A.z si lexicale plutôt que de la dynamique de la portée est choisi.

Noter que, si une fonction n'est jamais défini une fois*, il est commun d'appeler à partir de plusieurs endroits (et on peut même appeler récursivement). Ainsi, alors qu'il est assez trivial pour effectuer une portée lexicale en utilisant le code statique, la dynamique de la portée est plus compliqué parce que le même mot-clé (dans la même fonction) peut résoudre de différentes variables (à partir de différents espaces de nom) lors des différents appels à cette fonction (vous obligeant à parcourir le programme et de suivre la façon dont la pile d'appel des modifications en cours d'exécution).

*(À l'exception de template langues..)