Portée des déclarations

La portée d'une déclaration est la region dans le texte du programme où la déclaration est pontentiellement visible (autrement dit, pontentiellement utilisable).

• Portée d'un identificateur local: c'est le texte du programme qui va du point de son introduction jusqu'au end qui finit le corps du sous-programme. Dans notre exemple, la portée de la déclaration du paramètre formel x et de la variable z est tout le corps de la fonction succeseur.
  

• Portée d'un identificateur global: va du point de son introduction jusqu'au end qui finit les actions du programme principal. Dans l'exemple, la portée des identificateurs x, y, un déclarés dans le programme principal est le texte de tout le programme.
  

Ces règles ont pour conséquence:

• Les identificateurs locaux d'un sous-programme ne sont pas visibles à l'extérieur de celui-ci,

• Une fois un sous-programme desactivé (c.a.d. une fois son exécution finie), la liaison pour chaque identificateur local devient inactive. Les liaisons locales ont une durée de vie égale à celle de l'activation du sous-programme.

Nous changeons légèrement l'exemple:

procedure exemple is
  un : constant integer := 1;
  x,y : integer := 1;
  function succeseur(x:integer) return integer is
  begin
      return(x + un);
  end succeseur;
begin
  y := x + succeseur(3);
end exemple;

D'après ces règles:

• L'instruction y := x + succ(3) du programme principal se trouve dans la portée des déclarations de x,y du programme principal. Il est clair que les deux variables dont on parle ici sont bien les x,y globales du programme.
  

• La constante un est globale. Sa portée inclut, en particulier, le texte du sous-programme où apparaît return (x + un). Ainsi, le sens à donner à un ici est celui introduit par la liaison globale entre un et 1.
  

• Il y a deux déclarations de x dont la portée s'étend jusqu'au texte du sous-programme où apparaît return (x + un): la déclaration globale, et celle du paramètre formel. Laquelle doit être prise en compte pour donner sens à cet instruction?

La notion de portée nous dit où chaque déclaration est pertinente, mais elle ne nous dit pas comme choisir entre plusieurs déclarations pertinentes.

Visibilité de déclarations

La visibilité d'une déclaration est la region du programme où toute occurrence de l'identificateur est lié par cette déclaration. En Ada, une déclaration est visible partout dans sa portée, sauf si une autre déclaration du même identificateur est introduite dans l'espace de cette portée.

Ainsi, une déclaration est visible:

• soit, dans toute sa portée, si celle-ci ne contient pas de nouvelle déclaration de l'identificateur,
  

• soit, du point qui va de cette déclaration jusqu'à la prochaine déclaration du même identificateur qui se trouve dans la portée de la première.

D'après ces règles on constate:

• L'occurrence de x dans le corps de successeur est liée par la déclaration du paramètre formel, et non pas par la première déclaration de x.
  

• A l'intérieur de la fonction, la première déclaration de x est masquée par la déclaration du paramètre.
  

Masquage de déclarations

Une déclaration d'identificateur n'est pas forcément visible dans toute sa portée. Toute nouvelle déclaration de l'identificateur qui se trouve dans la portée de la première, masque la visibilité de celle-ci, dans toute la portée de la deuxième déclaration. La première déclaration de l'identificateur devient inaccesible (non visible) dans toute la portée de la deuxième déclaration.

Dans l'exemple, les deux déclarations de x (celle globale et celle du paramètre formel) ont pour portée le corps de la fonction successeur. Mais, seul le paramètre formel est visible à l'intérieur de la fonction. En effet, la déclaration globale de x a pour portée tout le programme, y compris la fonction, mais n'est pas visible dans celle-ci. On dit qu'elle est masquée par la déclaration du paramètre x.

Exemple: Une fonction qui contient une fonction locale,

procedure exemple2 is
   a,b,c : integer;
   function somme_carres(x,y : integer) return integer is
       function carre(x : integer) return integer is
       begin
           return(x*x);
       end carre;
       z : integer;
   begin
       z := carre(x) + carre(y);
       return(z);
   end somme_carres;
begin
 -- Lecture de a,b ...
    c := somme_carres(a,b);
 -- Affichage de c ...
end exemple2;