Les sous-programmes.

Tout programmeur sait qu'il n'est pas envisageable d'écrire une quelconque application sans avoir la possibilité de définir des sous-programmes.

Dans la majorité des applications, on dispose de lignes de code stockées dans des bibliothèques de fonctions et de modules réutilisables dans de multiples endroits. Le sous-programme représente la base incontournable dans la notion de code réutilisable.

Cette fonctionnalité est constamment utilisée lorsqu'on écrit du code en PIR, en fait, comme nous l'avons déjà constaté, le langage est entièrement basé sur cette présentation car tout code PIR est un sous-programme qui est déclaré et ne peut exister qu'en tant que tel.

Il a été dit à plusieurs reprises que le programme de plus haut niveau, le programme principal, est lui même un sous-programme qu'on a coutume de référencer :main par la suite, d'autres sous-programmes sont créés et appelés pour réaliser l'ensemble des opérations nécessaires.

C'est aussi l'utilisation de sous-programmes, au sens PIR du terme qui nous permettra d'écrire des morceaux de code pour déclarer des objets et y attacher des méthodes.

Nous allons maintenant présenter dans le détail la manière de réaliser et de déclarer les sous-programmes, de quelle façon s'opère transmission de la liste de paramètres et enfin, de savoir comment les utiliser au mieux pour développer des applications complexes.

Nous avons vu que la machine virtuelle Parrot est, au final, destinée à supporter de multiples langages [Langages], chacun d'eux disposant de ses propres conventions et sa propre syntaxe pour gérer la définition et l'appel de ses fonctions.

Le but de PIR n'étant pas d'être lui même un langage de haut niveau, il se doit de proposer les outils de base afin que chaque langage qui sera implémenté par son intermédiaire puisse les utiliser pour réalises ses propres fonctionnalités.

C'est pour cette raison que la syntaxe de PIR pour l'utilisation des sous programmes est d'une grande simplicité.

Les conventions d'appel.

Les PPC (Parrot Calling Conventions) [PPC] décrivent en détail comment la machine virtuelle doit faire référence à un sous-programme, doit gérer la rupture de séquence puis récupérer l'adresse de retour. Elles définissent aussi comment sera transmise la liste des paramètres et de quelle manière seront récupérés les résultats. Elles sont écrites en partie en langage C et en partie en PASM (Parrot Assembly).

Les détails de fonctionnement d'un sous-programme ou d'une fonction restent cachés à la grande majorité des programmeurs car ces derniers n'ont généralement pas besoin de les connaître. PIR dispose de multiples constructions pour procéder à cette dissimulation.

Le principe des Parrot Calling Conventions est basé sur la CPS (Continuation Passing Style) pour transférer le contrôle à un sous-programme et gérer la pile des adresses de retour.

Si, comme nous venons de le dire, le grande majorité des utilisateurs peuvent totalement ignorer les détails du mécanisme qui gèrent ces actions, il n'en est pas de même pour tous ceux qui souhaitent en exploiter toute les capacités et qui, de ce fait, doivent en connaître le fonctionnement détaillé.

Appels de sous-programmes.

Il ne faut pas se le cacher, la gestion d'un sous-programme cache une grande complexité.

Au niveau de la structure de base de la machine virtuelle, cela va se traduire par l'instanciation d'un PMC sous-programme. Il est ensuite nécessaire de créer un PMC de continuation pour gérer l'adresse de retour à la fin du sous-programme, puis transmettre la liste d'arguments, résoudre l'adresse symbolique représentée par le nom du sous-programme en question et, en fin de compte, renvoyer les résultats et les mémoriser aux emplacements qui auront été spécifiés au moment de l'appel (variables ou registres).

Tout ce travail étant destiné à la gestion d'une seule et unique instruction, l'appel à la fonction, ne prend pas en compte le complexité de l'exécution du sous-programme lui-même. Il est donc évident que l'instruction d'appel à un sous-programme apparaîtra incroyablement simple en comparaison de la difficulté du travail sous-jacent.

À la base, l'appel d'un sous-programme en PIR est très proche, bien que moins flexible, de ce qu'on a l'habitude de voir dans n'importe quel langage de haut niveau.

Nous avons aussi vu dans nos précédents exemples que la syntaxe de PIR est particulièrement prolixe, cet état de choses présente certains avantages.

Ainsi, l'exemple suivant montre comment sera extraire la référence à un sous-programme nom de la table des symboles globaux pour le stocker dans un PMC $P1 afin d'y faire référence.

  find_global $P1, "nom"
    .begin_call
    .arg Valeur1
    .arg Valeur2
    .call $P1
    .result $I0
  .end_call

L'ensemble des instructions que l'on trouve entre les deux directives .begin_call et .end_call se comporte comme un bloc, la directive .arg positionne et transmet les arguments de la liste d'appel, et en fin de compte, l'instruction .call fait référence au PMC $P1 préalablement positionné. Enfin l'instruction .result nous indique que le résultat renvoyé par le sous-programme sera stocké dans le registre $I0.

Nous utiliserons ultérieurement la fonctionnalité que nous venons de décrire.

Déclaration de sous-programmes.

La définition de l'instruction d'appel d'un sous-programme n'est qu'une partie du problème. Il est aussi important de savoir déclarer le sous-programme et en écrire les lignes de code.

Nous l'avons déjà vu à de nombreuses reprises, c'est la directive .sub qui permet de déclarer un sous-programme, en fait, une unité de compilation, et la directive .end qui en indique la fin.

 .sub "Main" :main
    * * *
  .end

La description et le typage des paramètres se fait au moyen de la directive .param. Cette dernière, outre le fait qu'elle définit les paramètres, créée aussi pour chacun d'eux une variable locale.

  .param int c

Enfin, la directive .return indique que le sous-programme se termine et, optionnellement, positionne la valeur qui sera retournée en fin de calcul.

  .return (valeur)

Si nous reprenons l'exemple de la factorielle en appliquant ce qui vient d'être dit, le sous-programme FACTORIELLE devient une unité de compilation au même titre que le programme principal main. Dans ces conditions, PIR résoudra le nom des diverses unités de compilation de la même manière que sont traitées les étiquettes dans un programme.

  coruscant chris$ cat factorielle.pir 
  # sous-programme.
  .sub factoriel
    .param int nombre
    .local int factorielle
    factorielle = 1
  BOUCLE:
    if nombre == 1 goto FIN
      factorielle *= nombre
      nombre -= 1
      branch BOUCLE
  FIN:
     .return (factorielle)
  .end

  .sub "main" :main
    $P0 = getstdin
    .local int nb
    .local int resultat
    print "Donnez moi une valeur entiere : "
    $S0 = readline $P0
    nb = $S0
    resultat =  factoriel(nb)
    print "La factorielle de "
    print nb
    print " est egale a "
    print resultat
    print ".\n"
    end
  .end
  coruscant chris$ parrot factorielle.pir 
  Donnez moi une valeur entiere : 6
  La factorielle de 6 est egale a 720.
  coruscant chris$

Analysons les lignes que nous venons d'écrire. On commence par définir une unité de compilation factoriel, qui sera aussi un sous-programme, au moyen de la directive que nous connaissons .sub. Ce sous-programme va récupérer comme paramètre, une valeur entière, qui lui sera transmise par l'intermédiaire de la variable locale nb. Comme nous l'avons dit, c'est la directive .param qui fait savoir au sous programme qu'il y a un paramètre à récupérer, que ce paramètre est une valeur entière (int) et qu'elle sera mémorisée dans la variable locale nombre. Nous aurons par ailleurs besoin d'une variable locale entière factorielle qui sera initialisée à 1 et qui nous servira à effectuer le calcul.

La boucle permet de manière très classique d'effectuer le produit des valeurs successives de nb à 1 au moyen de la variable compteur.

À la fin, on retourne la valeur qui a été calculée et mémorisée dans la variable factorielle au moyen de l'instruction .return (factorielle).

Le programme principal se contente de définir une valeur entière nb qui sera lue et contiendra la valeur dont nous désirons calculer la factorielle. Elle sera passée comme paramètre au sous-programme qui vient d'être défini.

La valeur de retour récupérée dans la variable locale resultat sera alors affichée.

Passage d'une liste de paramètres.

Pour illustrer ceci, revoici un classique de la programmation, l'énumération de Conway.

Ce programme va nous permettre de mettre en évidence, outre le passage de la liste de paramètres, plusieurs caractéristiques que nous avons étudié jusqu'à présent.

  coruscant chris$ cat conway.pir
  .sub "Enumeration_Conway" :main
    .local string ch_ref, ch_res, car_ref, car_comp
    .local int occurence, nb_lignes
    nb_lignes = 11
    print "1\n"
    ch_ref = "1"
  CALCUL:
    occurence = 0
    ch_res = ""
    substr car_ref,ch_ref,0,1
  EXPLORE:
    occurence += 1
    substr ch_ref,ch_ref,1
    unless ch_ref goto FINI
    substr car_comp,ch_ref,0,1
    if car_ref == car_comp goto EXPLORE
    ch_res = CONSTRUIRE(occurence, car_ref, ch_res)
    car_ref = car_comp
    occurence = 0
    goto EXPLORE
  FINI:
    ch_res = CONSTRUIRE(occurence, car_ref, ch_res)
    print ch_res
    print "\n"
    ch_ref = ch_res
    nb_lignes -= 1
    if nb_lignes goto CALCUL
  .end

  .sub CONSTRUIRE
    .param int occurence
    .param string car_ref
    .param string ch_res
    .local string c
    c = occurence
    c .= car_ref
    ch_res .= c
    .return (ch_res)
  .end
  coruscant chris$ parrot conway.pir
  1
  11
  21
  1211
  111221
  312211
  13112221
  1113213211
  31131211131221
  13211311123113112211
  11131221133112132113212221
  3113112221232112111312211312113211
  coruscant chris$

Ici, le sous-programme CONSTRUIRE récupère une liste de trois valeurs représentatives de trois chaînes de caractères et retourne un résultat, lui aussi sous forme d'une chaîne de caractères.

Les paramètres nommés.

Dans la méthode de transmission que nous venons de voir, il y a plusieurs paramètres, et ils doivent être transmis dans un ordre strict.

Les paramètres sont alors appelés positionnels et c'est la correspondance entre leur ordre dans la liste d'appel et l'ordre dans lequel ils sont déclarés en tant que paramètres dans le sous-programme qui permet d'effectuer le passage des valeurs.

Il existe une autre manière de transmettre les paramètres à un sous programme, on appelle cette méthode les paramètres nommés. Ici, l'ordre est quelconque et c'est le nom qui va permettre d'effectuer l'affectation de la bonne valeur au bon paramètre.

  coruscant chris$ cat parametres.pir
  .sub ident
    .param string prenom :named ("prenom")
    .param string nom :named ("nom")
    .param string mail :named ("mail")
    print "Votre prenom est : "
    print prenom
    print ".\n"
    print "Votre nom est : "
    print nom
    print ".\n"
    print "Votre mail est : "
    print mail
    print ".\n"     
  .end

  .sub "main" :main
    .local string n
    .local string p
    .local string m
    n = "Aperghis"
    p = "Christian"
    m = "chris@aperghis.fr"
    ident("mail" => m, "nom" => n, "prenom" => p)
  .end
  coruscant chris$ parrot parametres.pir
  Votre prenom est : Christian.
  Votre nom est : Aperghis.
  Votre mail est : chris@aperghis.fr.
  coruscant chris$

La liste d'appel du sous-programme indique que la valeur d'appel contenue dans la variable locale m sera récupérée dans le corps du sous-programme par la variable locale mail, et le raisonnement est identique pour les autres valeurs.

C'est dans le corps du sous-programme que la variable mail est déclarée comme étant une chaîne de caractères passée par l'intermédiaire d'un paramètre nommé (:named).

L'intérêt des arguments nommés est de s'affranchir, dans le cas de listes de paramètres un peu trop longues, d'éventuelles erreurs dues à une inversion accidentelle dans l'ordre des valeurs de la liste d'appel.

Les paramètres optionnels.

Certains paramètres peuvent ne pas être présents lors de l'appel. On parle dans ce cas de paramètres optionnels.

Dans les langages qui proposent cette facilité, le principe est de pouvoir transmettre une valeur si le paramètre est présent dans la liste d'appel ou de prendre une valeur par défaut dans le cas contraire.

En fait, PIR ne dispose pas cette caractéristique en tant que telle, mais il propose une solution pour faire en sorte que certains paramètres puissent ne pas se présenter.

C'est un indicateur spécifique attaché au paramètre qui va nous permettre de savoir si le paramètre optionnel en question s'est vu affecter une valeur par l'intermédiaire de la liste d'appel.

En définitive, un paramètre déclaré comme étant optionnel peut être vu comme contenant deux informations distinctes, la première étant la valeur éventuellement transmise, la seconde représentant l'indicateur qui va permettre de savoir si, effectivement, une valeur lui a été affectée.

  .param string parametre :optional
  .param int present :opt_flag

La directive :optional permet d'indiquer que le paramètre correspondant représente une valeur optionnelle et que, de ce fait, va lui être attaché un indicateur present défini par la directive :opt_flag.

C'est son contenu qui permet de savoir de manière effective si une valeur a été transmise au paramètre par l'intermédiaire de la liste d'appel (1) ou si aucune valeur n'a été spécifiée (0).

Le test de cet indicateur permet alors, si nécessaire, d'affecter une valeur par défaut au paramètre en question ou de prendre toute décision en fonction du calcul à effectuer.

  coruscant chris$ cat optionnel.pir
  .sub valeur
    .param num valeur :optional
    .param int defaut :opt_flag
    print "Indicateur : "
    print defaut
    print ".\n"
    if defaut==0 goto DEFAUT
    print "Parametre transmis : "
    print valeur
    print ".\n"
    .return()
  DEFAUT:
    valeur = 0
    print "Aucun parametre transmis, on donne la valeur par defaut.\n"
  .end

  .sub "main" :main
    .local num n
    print "Appel avec une valeur effective (3,14159265).\n"
    n = 3.14159265
    valeur(n)
    print "Appel sans parametre.\n"
    valeur()   
  .end
  coruscant chris$ parrot optionnel.pir
  Appel avec une valeur effective (3,14159265).
  Indicateur : 1.
  Parametre transmis : 3.14159265.
  Appel sans parametre.
  Indicateur : 0.
  Aucun parametre transmis, on donne la valeur par defaut.
  coruscant chris$

Il est à noter que les paramètres optionnels peuvent indifféremment être des paramètres positionnels ou des paramètres nommés, toutefois, lorsqu'on les utilise avec des paramètres nommés, ils doivent impérativement apparaître à la fin de la liste, après les paramètres positionnels. De plus, la directive :opt_flag doit nécessairement se trouver immédiatement après la directive :optional.

Première erreur :

  .sub 'parametres'
    .param int valeur_optionnelle :optional
    .param int indicateur :opt_flag
    .param pmc valeur <- Cette ligne est fausse.

On aurait dû écrire :

  .sub 'parametres'
    .param pmc valeur
    .param int valeur_optionnelle :optional
    .param int indicateur :opt_flag

Seconde erreur :

  .sub 'parametres'
    .param int indicateur :opt_flag
    .param int valeur_optionnelle :optional <- Faux.

On aurait dû écrire :

  .sub 'parametres'
    .param int valeur_optionnelle :optional
    .param int indicateur :opt_flag

Troisième erreur :

  .sub 'parametres'
    .param int valeur_optionnelle :optional
    .param pmc valeur <- Faux.
    .param int indicateur :opt_flag

On aurait dû écrire :

  .sub 'parametres'
    .param pmc valeur
    .param int valeur_optionnelle :optional
    .param int indicateur :opt_flag

Et il est aussi possible de mélanger des paramètres optionnels et des paramètres nommés.

Nous allons illustrer ceci avec l'exemple d'un sous-programme qui calcule la racine n-ième d'un nombre, et ce, quel que soit n.

Le sous-programme récupère deux paramètres nommées, la Valeur et la Racine, la particularité étant que le second paramètre peut être absent. Si c'est la cas, la valeur par défaut sera 2 et on procédera au calcul de la racine carrée.

  coruscant chris$ cat optionnel.pir
  .sub racine
    .param num N :named ("Valeur")
    .param num Exp :named ("Racine") :optional
    .param int ind :opt_flag
    .local num X0, X1
    .local int I
    if ind == 1 goto RACINE
  # Parametre optionnel absent, on prend 2 par defaut.
    Exp = 2
  RACINE:
    X0 = N
    I = 0
  BOUCLE:
    I += 1
    $N2 = Exp - 1.0
    $N1 = X0 * $N2
    $N2 = X0 ** $N2
    $N2 = N / $N2
    X1 = $N1 + $N2
    X1 /= Exp
    $N2 = X0 - X1
    if $N2 > 0 goto OK
    $N2 = - $N2
  OK:  
    if $N2 < 0.00000000000001 goto FIN
    X0 = X1
    goto BOUCLE
  FIN:
    .return (I, X1)
  .end

  .sub "Racine nieme d'un nombre" :main
    .local num e, pi, Rac
    .local int i
    e = 2.71828183
    pi = 3.14159265
    (i, Rac) = racine ("Valeur" => pi, "Racine" => e)
    print "Racine e-ieme de pi = "
    say Rac
    print "Trouvee en "
    print i
    say " iterations."
    (i, Rac) = racine ("Valeur" => 10)
    print "Racine carree de 10 = "
    say Rac
    print "Trouvee en "
    print i
    say " iterations."
  .end
  coruscant chris$ parrot optionnel.pir
  Racine e-ieme de pi = 1.52367105385469
  Trouvee en 7 iterations.
  Racine carree de 10 = 3.16227766016838
  Trouvee en 7 iterations.
  coruscant chris$

Les fonctions récursives.

N'abandonnons pas les bonnes habitudes. La tradition veut que pour illustrer la notion de récursivité on prenne comme exemple la fonction factorielle.

  return (n > 1 ? n * _fact(n - 1) : 1)

Pour changer un peu, au lieu de se contenter de calculer une simple factorielle, le programme proposé va calculer les factorielles des n premiers nombres entiers.

  coruscant chris$ cat facto.pir
  .sub _factoriel
    .param int valeur
    .local int factorielle
    if valeur > 1 goto RECURSION
      factorielle = 1
      goto RETOUR

  RECURSION:
    $I0 = valeur - 1
    factorielle = _factoriel($I0)
    factorielle *= valeur

  RETOUR:
      .return (factorielle)
  .end

  .sub _main :main
    .local int facto, nombre
    print "Calcul des factorielles des cinq premiers nombres entiers.\n"
    nombre = 0
  BOUCLE:
    facto = _factoriel(nombre)
    print "La factorielle de "
    print nombre
    print " est egale a "
    print facto
    print ".\n"
    inc nombre
    if nombre <= 5 goto BOUCLE
  .end
  coruscant chris$ parrot facto.pir
  Calcul des factorielles des cinq premiers nombres entiers.
  La factorielle de 0 est egale a 1.
  La factorielle de 1 est egale a 1.
  La factorielle de 2 est egale a 2.
  La factorielle de 3 est egale a 6.
  La factorielle de 4 est egale a 24.
  La factorielle de 5 est egale a 120.
  coruscant chris$

Le langage PIR, seconde partie

Chapeau

Introduction.

Les entrées sorties.

STDIN et STDOUT.

Les fichiers.

Les informations système.

Les opérateurs arithmétiques.

Les labels.

Généralités.

Règles d'utilisation.

Les instructions de contrôle.

La rupture de séquence inconditionnelle `goto`.

La rupture de séquence conditionnelle.

La réalisation des boucles.

Les boucles non bornées `while` et `until`.

La boucle bornée `for`.

Macros de haut niveau.

Retour sur les unités de compilation.

Les sous-programmes.

Les conventions d'appel.

Appels de sous-programmes.

Déclaration de sous-programmes.

Passage d'une liste de paramètres.

Les paramètres nommés.

Les paramètres optionnels.

Les fonctions récursives.

Les continuations.

Les tail calls

Création et utilisation des continuations.

Les outils de mise au point.

Suivre le déroulement du programme.

Trace du programme.

Une petite distraction.

Pour conclure provisoirement.

Références

Le langage PIR, seconde partie

Chapeau

Introduction.

Les entrées sorties.

STDIN et STDOUT.

Les fichiers.

Les informations système.

Les opérateurs arithmétiques.

Les labels.

Généralités.

Règles d'utilisation.

Les instructions de contrôle.

La rupture de séquence inconditionnelle goto.

La rupture de séquence conditionnelle.

La réalisation des boucles.

Les boucles non bornées while et until.

La boucle bornée for.

Macros de haut niveau.

Retour sur les unités de compilation.

Les sous-programmes.

Les conventions d'appel.

Appels de sous-programmes.

Déclaration de sous-programmes.

Passage d'une liste de paramètres.

Les paramètres nommés.

Les paramètres optionnels.

Les fonctions récursives.

Les continuations.

Les tail calls

Création et utilisation des continuations.

Les outils de mise au point.

Suivre le déroulement du programme.

Trace du programme.

Une petite distraction.

Pour conclure provisoirement.

Références

La rupture de séquence inconditionnelle `goto`.

Les boucles non bornées `while` et `until`.

La boucle bornée `for`.