A!ociation
Prolog
HERITAGE
6. L'environnement
6.1. Comment sortir de Prolog
6.2. Démarrage automatique d'un programme Prolog
6.3. Edition de programmes
6.4. Date, temps et mesures
6.5. Lien avec le système
6.6. Utilisation du debugger
6.7. Modification et visualisation de l'état courant
6.8. Gestion automatique des espaces et des piles
Parmi les règles prédéfinies qui permettent à l'utilisateur de communiquer avec l'extérieur de Prolog, ce chapitre décrit celles qui sont indépendantes du système particulier utilisé. Celles qui, au contraire, dépendent de l'implantation considérée sont décrites dans le manuel d'utilisation.
6.1. Comment sortir de Prolog
exit exit(s)
Fait sortir de Prolog en sauvant la totalité des programmes couramment connus, y compris ceux qui constituent le superviseur Prolog II+. La sauvegarde est faite dans le fichier de nom s, ou bien pour la forme sans argument dans le fichier de nom prolog.po.
Remarque : Il est possible de sauver uniquement les modules que vous avez créés ou modifiés pendant la session (commande save - cf. paragraphe 3.7) et de quitter Prolog en faisant la commande quit.
quit quit(n)
Fait quitter Prolog sans rien sauver. La valeur n est envoyée au système d'exploitation à titre de «statut de terminaison». Quelque soit ce système, si n vaut 0 alors la valeur envoyée est celle qui correspond à «pas d'erreur» (cette valeur peut être non nulle).
La première forme quit, équivaut à quit(0).
6.2. Démarrage automatique d'un programme Prolog
Si l'état binaire sur lequel Prolog est lancé, contient des modules possédant une règle ini_module, chacune de ces règles est effacée (dans un ordre défini par
Prolog) dès la fin de l'initialisation. Ensuite, Prolog tente d'effacer le but :to_begin.
©PrologIA
R 6 - 2
Manuel de Référence
La règle :to_begin n'est pas définie dans l'état initial. Si l'utilisateur veut faire démarrer automatiquement un programme, il doit ajouter la règle:
:to_begin -> xxxx ; où xxxx est le but initial à effacer de son programme d'application. Il doit ensuite sauvegarder cet état. Lorsque plus tard il appellera Prolog avec ce nouvel état, xxxx sera immédiatement exécuté.
A!ociation
Prolog
HERITAGE
6.3. Edition de programmes
-
-
-
-
Prolog II+ étant un compilateur incrémental, il vous permet d'éditer des règles sans quitter Prolog, en utilisant un éditeur que nous appellerons ici éditeur résident.
L'éditeur résident est activé par la commande Prolog edit
Il existe plusieurs variantes de cette commande pour:
-
-
modifier un ou plusieurs paquets de règles.
éditer et recompiler un module source.
éditer un fichier de texte quelconque.
A propos d'édition, il faut savoir que : les règles sont supprimées de l'espace du code de Prolog pour être écrites dans le fichier de texte qui sert pour l'édition. A la fin de l'édition, le fichier est réinséré.
l'édition compile et par conséquent l'édition de faits non compilés les transformera en règles compilées.
à tout moment, les règles n'existent qu'en un seul exemplaire : soit comme code Prolog, soit comme source Prolog.
si une interruption utilisateur survient, l'espace du code sera tout de même modifié, de façons différentes en fonction du moment de l'interruption.
l'édition de règles non visibles provoque la suppression de ces règles, mais ne les fournit pas sous forme de source!
6.3.1. Modifier des paquets de règles
Cette commande provoque l'édition des paquets de règles listés en argument. A la fin de l'édition, les paquets édités sont réinsérés à la place des paquets originaux.
Les paquets peuvent appartenir à plusieurs modules différents, c'est alors le contexte de lecture/écriture du module du premier paquet qui est utilisé.
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 3
edit(i/a) edit(l)
i/a représente le paquet de règles dont l'accès est l'identificateur i, et le nombre d'arguments est a.
l est une liste (terminée ou non par nil) d'éléments i/a.
Au retour d'un appel de l'éditeur résident, Prolog peut déceler une erreur de syntaxe dans les règles que vous venez d'éditer. Il affiche alors un message avec le numéro et le contenu de la ligne contenant l'erreur, le diagnostic correspondant et vous demande si vous désirez recommencer le cycle d'édition et compilation afin de corriger la faute, ou abandonner.
L'abandon provoque le retour à prolog, les règles non insérées sont supprimées.
Note:
Il peut arriver que le texte que vous venez d'éditer comporte une erreur difficile à déceler.
Sachez qu'à la suite d'une utilisation de l'éditeur résident, un fichier nommé
PROEDIT.PRO a été créé dans le répertoire courant: il contient les règles
éditées dans leur état final.
Ce fichier peut vous aider à reconstituer l'état courant de votre programme.
Pour cela, abandonnez l'édition. Vous vous retrouvez alors sous Prolog, sans les règles éditées non encore lues. Sauvez ce programme et, hors
Prolog, utilisez un éditeur de textes pour analyser le morceau manquant depuis PROEDIT.PRO.
6.3.2. Editer et recompiler un module source
Cette fonctionnalité permet de modifier et recompiler le texte source d'un module déjà chargé: l'édition se fait avec la mise en forme originale.
editm(m)
m est une chaîne. Supprime toutes les règles du module m, et lance l'édition du fichier source correspondant. La version éditée est recompilée et vient remplacer l'ancienne version.
Si le fichier source ne peut être trouvé, alors l'édition se fait sur un source créé par décompilation du module. Ce fichier source est appelé PROEDIT.Mx où x est un numéro engendré par Prolog et de valeur différente pour des modules de nom différent.
Note:
Les règles qui auraient pu être ajoutées par insert ou assert dans le module pendant l'exécution sont effacées avant rechargement du module.
©PrologIA
R 6 - 4
Manuel de Référence
6.3.3. Editer un fichier de texte quelconque
edit(s)
s est une chaîne. Permet d'éditer le fichier de nom s.
6.4. Date, temps et mesures
reset_chrono, chrono(x)
chrono unifie x avec le temps en secondes écoulé depuis le dernier
reset_chrono.
reset_cpu_time, cpu_time(x)
cpu_time unifie x avec le temps cpu en millisecondes écoulé depuis le dernier
reset_cpu_time.
date(j,m,a,s)
Calcule les arguments j,m,a,s de la date courante. Les quatre arguments désignent respectivement le jour du mois, le mois, l'année et le rang du jour dans la semaine (dimanche=0, lundi=1,...).
date_string(s)
Calcule la date courante, exprimée en anglais, et unifie la chaîne correspondante avec s.
date_stringF(s)
Calcule la date courante, exprimée en français, et unifie la chaîne correspondante avec s.
week(n,s)
Donne dans s la chaîne correspondant au jour de la semaine dont le rang est n et vice versa.
month(n,s)
Donne dans s la chaîne correspondant au mois dont le rang est n et vice versa.
delay(n)
Temporise n millisecondes.
time(x)
Donne un temps absolu en secondes. L'origine de ce temps est variable d'une machine à une autre.
time(h,m,s)
Calcule les arguments h, m, s de l'heure courante. Ils représentent respectivement l'heure, les minutes et les secondes.
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 5
6.5. Lien avec le système
sys_command(s)
Permet d'exécuter une commande du système d'exploitation représentée par la chaîne s. Quand la commande appelée provoque une erreur, sys_command génère une erreur "ERREUR SYSTEME" avec en complément d'erreur le status retourné par le système d'exploitation.
Sous certains systèmes d'exploitation (UNIX par exemple), ce prédicat peut
être grand consommateur de mémoire. On pourra alors le redéfinir à l'aide d'un coprocessus (sur ces systèmes, voir le chapitre sur les coprocessus).
getenv(s,x)
Unifie x avec la chaîne représentant la valeur de la variable système d'environnement dont le nom est défini dans la chaîne s. Si la variable n'est pas définie, x est unifié avec une chaîne vide.
set_import_dir(s)
Définit un répertoire de référence, qui est consulté après le répertoire courant quand les fichiers n'y ont pas été trouvés, par les primitives qui manipulent des fichiers en lecture telles que : input, insert, load. La chaîne de caractère s concaténée à un nom de fichier, doit définir un nom complet compréhensible par le système d'exploitation.
lkload(s1,s2)
Cette primitive n'est disponible que sous certains systèmes d'exploitation, voir le manuel d'utilisation. Lorsqu'elle est présente, elle permet d'effectuer un lien et un chargement dynamiques de programmes externes.
ms_err(n, s)
Unifie s avec le texte de l'erreur numéro n. Pour cela, Prolog fait une recherche dans le fichier d'erreurs err.txt qui doit être composé d'une suite de lignes du format suivant:
entier espace suite de caractères qui compose le texte de l'erreur.
Il est possible de rajouter des messages dans ce fichier en respectant le format indiqué. Il est conseillé d'utiliser des numéros de message au delà de 1000.
6.6. Outil de mise au point de programmes
Le debugger Prolog, ou outil de mise au point de programmes, permet une trace interactive des programmes sans modifier leur sémantique, et sans consommation supplémentaire de mémoire. Il permet, entre autres, de positionner des points d'arrêt, de pister en pas à pas avec saut éventuel de morceaux de programme, d'imprimer l'état de la démonstration en cours, et de visualiser les backtracking.
Le prédicat prédéfini statistics, après une éxécution du programme avec le debugger actif, peut aider à configurer les espaces de Prolog.
©PrologIA
R 6 - 6
Manuel de Référence
Note: Le code optimisé ne permet de reconstruire le source que de manière
équivalente, et ne permet pas au debugger de visualiser toutes les informations s'y rapportant. Si l'utilisateur désire suivre une représentation exacte de son programme, il faut que les règles aient été compilées sans optimisation avec l'option adéquate, au lancement de Prolog.
6.6.1. Mode trace
L'outil de mise au point mixe deux modes de fonctionnement :
• un mode trace, où il visualise l'exécution,
• un mode interactif, où il permet de prendre le contrôle au cours de l'exécution et d'effectuer des actions.
Dans un premier temps, si l'on ne veut pas se plonger dans le détail des commandes du mode interactif, le mode trace permet d'afficher toutes les informations nécessaires à la compréhension du programme.
Le mode trace est donc une approche simple et immédiate pour se rendre compte de l'exécution d'un programme.
Chaque but effacé est affiché avec ses arguments unifiés sur la règle choisie pour l'effacement courant. Les backtracking sont annoncés en précisant le prédicat pour lequel il restait des choix et le rang dans le paquet de la nouvelle règle.
Si le programme d'exemple menu.p2 est chargé et si le mode trace est actif, la séquence suivante montre la présentation de ces informations:
> repas(e,Chapon_farci,d); hors_d_oeuvre( Artichauts_Melanie) plat( Chapon_farci)
RECALL(2): plat / 1 plat( Chapon_farci) poisson( Chapon_farci) dessert( Sorbet_aux_poires)
{e=Artichauts_Melanie,d=Sorbet_aux_poires}
RECALL(2): dessert / 1 dessert( Fraises_chantilly)
{e=Artichauts_Melanie,d=Fraises_chantilly}
RECALL(3): dessert / 1 dessert( Melon_en_surprise)
{e=Artichauts_Melanie,d=Melon_en_surprise}
…
Pour faciliter la lisibilité (pour des programmes qui font eux-mêmes des écritures sur la sortie courante), les informations fournies par la trace peuvent être redirigées sur un fichier.
Activation, désactivation
Le mode trace est actif dès l'effacement d'un des prédicats prédéfinis trace/0 ou
trace/1. Il est désactivé par l'effacement du prédicat prédéfini no_trace/0.
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 7
trace
Active la trace.
trace(f)
Active la trace. Redirigera toutes les impressions de la trace dans le fichier de nom f (chaîne Prolog). Le fichier est fermé à l'exécution d'un prédicat de désactivation de l'outil de mise au point. Si les impressions de mise au point
étaient déjà redirigées, le précédent fichier est fermé pour être remplacé par f.
no_trace
Désactive la trace.
6.6.2. Mode interactif
Si la trace est simple à activer, elle peut rapidement donner un flot d'informations important, où il serait difficile de se repérer. A ce moment là, le mode interactif devient d'une grande utilité puisqu'il permet d'aller directement à l'information importante. Ses atouts sont :
• les commandes de progression dans le code,
• le paramétrage de l'information à produire,
• les commandes annexes sur l'exécution.
Le mode interactif permet de choisir les informations qu'on veut extraire du programme, dans le format approprié, sans modifier le programme, et seulement dans les portions de code désignées. Il permet surtout, de prendre le contrôle où l'on souhaite, pour lancer des actions.
6.6.2.1.
Points d'arrêt
En mode interactif, le debugger va proposer sa banière d'invite (DBG) et attendre une commande sur chaque point d'arrêt. L'important pour avoir accès à l'interpréteur de commande est de bien définir les points d'arrêt. On en distingue deux types:
• les points d'arrêt fixes: ils subsistent tant que le mode debug est actif et tant qu'ils ne sont pas désactivés par commande;
• les points d'arrêt momentanés: ils ne sont valides que le temps d'une commande, qui définit en fait le prochain point de contrôle du debugger.
Un point d'arrêt se définit sur un prédicat, le debugger s'arrête ensuite dès que le programme courant fait appel à ce prédicat. L'arrêt de la machine Prolog se fera donc au moment où le but doit être effacé, avant que l'unification avec la tête de la règle choisie soit faite.
Des commandes spécifiques, ainsi que des prédicats prédéfinis, permettent de définir les points d'arrêt fixes. Les points d'arrêt momentanés sont définis implicitement par une commande de progression ou à l'activation du debugger.
©PrologIA
R 6 - 8
Manuel de Référence
Quand la machine Prolog tourne, avec le debugger actif, une interruption utilisateur poste un point d'arrêt momentané sur le but courant et le mode interactif est réactivé.
Les interruptions utilisateur sont ainsi interceptées et ne produisent pas d'erreur.
Voir les commandes du debugger +, -, b et les règles prédéfinies spy, no_spy,
show_spy.
6.6.2.2.
Progression dans le code
La progression dans le code se fait de point d'arrêt en point d'arrêt.
Trois granularités de progression sont possibles. On les utilisera en fonction de la
"proximité" de l'erreur, ou du type d'information que l'on veut extraire d'une partie du programme.
Les progressions possibles, à partir d'un point d'arrêt, sont:
1er cas: on connait l'endroit du programme qui fait défaut, on veut y aller directement et rapidement.
Réponse: (go to spy) aller jusqu'au prochain point d'arrêt fixe, qui peut se trouver n'importe où dans le code.
2ème cas: on veut voir "de près" l'exécution de la fonction, sans descendre au niveau bas de ses "sous-programmes".
Réponse: (next) aller jusqu'au prochain but de même niveau ou de niveau supérieur. On ne s'intéresse pas aux niveaux 1 inférieurs, c'est à dire que l'on ignore le corps du but courant.
3ème cas: on veut voir exactement toute l'exécution de la fonction, sans oublier aucune instruction.
Réponse: (step) aller jusqu'au prochain but.
A!ociation
Prolog
HERITAGE
1
Définition du niveau d'un but : on dira qu'un but de la question est de niveau 0. Si un but est de niveau n, les buts apparaissant dans la queue de sa règle sont tous du même niveau, égal à n+1.
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 9
Schématisons sur notre exemple de menu, les progressions possibles par next et step : repas
...
hors_d_oeuvre plat dessert step next viande
On remarquera que sur les assertions, step et next ont le même effet.
Les commandes de progression dans le code permettent de définir quel doit être le prochain arrêt et quelles informations doivent être obtenues entre temps. En effet, à chaque progression, on pourra choisir ou pas d'afficher les informations sur l'exécution de la portion de programme.
Voir les commandes du debugger RC, n, N, g, t.
6.6.2.3.
Terminer l'exécution
Ayant suffisamment dégrossi une partie du programme, il faut maintenant le terminer. Il est possible de :
- (go to end) continuer jusqu'à la fin du programme : en imprimant toutes les informations, en imprimant seulement celles concernant les points d'arrêt fixes, en quittant le mode debug et continuant normalement.
- (abort) interrompre le programme.
- (quit) quitter Prolog.
Voir les commandes du debugger a, e, G, T, q.
6.6.2.4.
Affichage des informations
Nous allons décrire maintenant à quels moments se font les affichages et sous quelle forme.
©PrologIA
R 6 - 10
Manuel de Référence
Quand?
Un Backtracking est généré
L'information est affichée. Elle indique que c'est une alternative (
RECALL
), le numéro de la nouvelle règle choisie et le but qu'on essaie à nouveau d'effacer. Le but à réessayer fait partie des buts à effacer, il peut donc être utilisé comme point d'arrêt.
Par exemple, sur l'éxécution :
> plat(Chapon_farci);
CALL: plat( Chapon_farci)
DBG:
CALL: viande( Chapon_farci)
DBG:
RECALL(2): plat( Chapon_farci)
DBG:
CALL: poisson( Chapon_farci)
DBG:
{}
L'information sur le backtracking est :
RECALL(2): plat( Chapon_farci)
Le numéro de la règle à réessayer est noté entre parenthèse
(2)
. Un point d'arrêt est mis au nouvel appel du but, sur : plat( Chapon_farci)
On a alors accès, sur cette autre alternative, à toutes les possibilités offertes par l'outil de mise au point.
Autre exemple, si un point d'arrêt fixe est mis sur plat/1, le debugger s'arrête sur toutes ses alternatives :
> repas(e,Chapon_farci,d);
CALL: repas( v147, Chapon_farci, v284)
DBG: +plat/1
DBG: g
(ajoute le point d'arrêt)
(go to spy)
CALL: plat( Chapon_farci)
DBG: g
RECALL(2): plat( Chapon_farci)
DBG: g
{e=Artichauts_Melanie,d=Sorbet_aux_poires}
{e=Artichauts_Melanie,d=Fraises_chantilly}
{e=Artichauts_Melanie,d=Melon_en_surprise}
CALL: plat( Chapon_farci)
DBG: g
RECALL(2): plat( Chapon_farci)
DBG: g
…
Une erreur est générée par la machine ou par un prédicat externe
Les points d'arrêt ne sont pas modifiés. Le message d'erreur est affiché, même si l'erreur est récupérée par un block, ainsi que la branche de résolution, au moment de l'erreur. Par exemple, sur l'exécution suivante :
> insert; toto(x,y) -> block(x,titi(y)) outl(x);
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 11 titi(y) -> string_ident(y,z) outl(z);
;
{}
> debug toto(x,12);
CALL: toto( v156, 12)
DBG: block
CALL: titi( 12)
DBG:
CALL: string_ident( 12, v360)
DBG:
ARGUMENT DE MAUVAIS TYPE
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^ titi / 1, rule number 1
^^^^^^^^ toto / 2, rule number 1
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
CALL: outl( 253)
DBG:
L'information sur l'erreur est :
ARGUMENT DE MAUVAIS TYPE
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^ titi / 1, rule number 1
^^^^^^^^ toto / 2, rule number 1
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
Il est possible de supprimer par commande, pour une session de mise au point, l'affichage de ces informations sur les erreurs. Voir la commande du debugger s.
Les erreurs produites en Prolog par block_exit ne sont pas mises en évidence par ce mécanisme. La règle prédéfinie block_exit, est traitée comme un prédicat ordinaire.
Pour être averti de ce type d'erreur, il suffit de mettre un point d'arrêt sur
block_exit/1 et block_exit/2.
Sur un point d'arrêt, c'est à dire quand un but est appelé
L'impression des buts peut se faire à deux moments, nous les appellerons avant unification et après unification. Voir les commandes du debugger p, P.
Les buts peuvent être imprimés avant l'unification, c'est-à-dire l'impression montre le but tel qu'il apparait dans la résolvante avant son unification avec la tête de la règle choisie pour son effacement.
Ils peuvent être imprimés après unification, c'est-à-dire l'impression a lieu après le choix de la règle et juste avant le prochain point d'arrêt. Par conséquent, on pourra avoir des résultats différents d'une exécution à l'autre pour des progressions de pas différents. Par exemple pour un but donné, si le pas de progression sous le debugger est celui d'un step, la machine Prolog aura simplement unifié le but avec la tête de la règle. Alors qu'après un pas tel que next, la machine Prolog aura exécuté le corps de la règle où des unifications se seront passées, et les arguments du but n'auront pas forcément les mêmes valeurs que précédemment.
©PrologIA
R 6 - 12
Manuel de Référence
Voyons sur notre exemple, la valeur des arguments après unification, dans les deux cas de progression :
> repas(e,p,d);
CALL: repas( v156, v191, v226)
DBG: P1
DBG:
CALL: hors_d_oeuvre( v156)
DBG:
(valide l'impression après unification) hors_d_oeuvre( Artichauts_Melanie)
CALL: plat( v191)
DBG: plat( v191)
CALL: viande( v191)
DBG: viande( Grillade_de_boeuf)
CALL: dessert( v226)
}
…
DBG: g
(go to spy)
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Sorbet_aux_poires
> repas(e,p,d);
CALL: repas( v156, v191, v226)
DBG: P1
DBG:
CALL: hors_d_oeuvre( v156)
DBG: hors_d_oeuvre( Artichauts_Melanie)
CALL: plat( v191)
(next)
DBG: n plat( Grillade_de_boeuf)
CALL: dessert( v226)
DBG: g
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Sorbet_aux_poires
}
…
Comment?
Présentation
D'une manière générale pour faciliter la lisibilité de la mise au point et différencier visuellement les messages du programme et ceux du debugger, il est possible de définir une marge (en nombre de caractères) pour les impressions du debugger.
Quelque soit le message transmis par le debugger, il sera indenté du nombre de caractères de la marge, pour l'affichage.
> repas(e,p,d);
CALL: repas( v156, v191, v226)
DBG:
CALL: hors_d_oeuvre( v156)
DBG:
CALL: plat( v191)
DBG: n
(next)
CALL: dessert( v226)
DBG:
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Sorbet_aux_poires
}
RECALL(2): dessert(v190)
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 13
DBG:
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Fraises_chantilly
}
RECALL(3): dessert(v190)
DBG:
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Melon_en_surprise
}
RECALL(2): viande(v165)
DBG:
CALL: dessert( v226)
DBG:
Une autre alternative est de rediriger les messages du debugger dans un fichier.
Dans ce cas, seule la séquence d'invite apparaîtra dans l'unité de trace.
Voir la commande du debugger i, ou les règles prédéfinies debug(f) et debug(n,f).
Précision
La précision de l'affichage des buts est paramétrable, selon la quantité d'informations que l'on souhaite obtenir. Trois modes sont disponibles :
- impression des prédicats sans leurs arguments éventuels mais précisant l'arité, sous la forme identificateur/arité.
- impression des prédicats avec leurs arguments éventuels, en notation fonctionnelle avec une limite en profondeur paramétrable. A partir d'une profondeur de 1000, la totalité du terme est imprimé. L'impression des arbres infinis en totalité utilise sa représentation en système d'équations. On ne sait pas dire à priori si l'impression restreinte d'un arbre infini est possible.
- impression des prédicats avec leurs arguments éventuels, sous forme d'arbre par le prédicat Dessin:draw_tree. Le module de dessin d'arbre doit
être chargé pour pouvoir utiliser ce mode. Il est possible de modifier la règle
Dessin:draw_tree, de manière à redéfinir ce qui est imprimé par le debugger.
Détail de la notation fonctionnelle en profondeur limitée :
On attribue une profondeur à chaque atome du terme à imprimer. Ne seront affichés que les atomes dont la profondeur est inférieure à celle fixée.
Le comptage se fait récursivement à partir du but à afficher, il démarre à 1. La profondeur est incrémentée lorsqu'on passe d'un terme à un sous terme de la manière suivante :
Si un terme fonctionnel f(a1, t2, …, as) apparaît dans un terme de profondeur n alors le foncteur f est de profondeur n, et ses arguments a1, …, as sont de profondeur n+1.
©PrologIA
R 6 - 14
Manuel de Référence
Si un n-uplet <t1, t2, …, ts> (t1 n'est pas un identificateur) apparaît dans un terme de profondeur n alors l'atome <> est de profondeur n, et les arguments du n-uplet t1, t2, …, ts sont de profondeur n+1.
Si une liste x.y apparaît dans un terme de profondeur n, alors x est de profondeur n et y est de profondeur n+1.
Par exemple, voici comment sont définies les profondeurs des atomes pour le terme suivant : element_de( 12, 1.
1 2 2
2.
3
3.
4
4.
5
5.
6 nil,
7 2 non)
En limite de profondeur 3, il sera imprimé : element_de( 12, [ 1, 2,…], non);
Voir la commande du debugger m.
Choix de l'information
Certaines parties du programme ont déjà été prouvées, il n'est pas nécessaire de les vérifier. En mode interactif, par la progression next, on peut éviter de développer le corps d'un prédicat. En mode trace (trace totale ou impression des informations entre deux points d'arrêt) la même possibilité est offerte.
Par exemple, si plat/1
ne doit pas être développé, on obtient :
> trace repas(e,p,d) !; hors_d_oeuvre( Artichauts_Melanie) plat( Grillade_de_boeuf) dessert( Sorbet_aux_poires)
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Sorbet_aux_poires
}
… au lieu de :
> repas(e,p,d) !; hors_d_oeuvre( Artichauts_Melanie) plat( v191) viande( Grillade_de_boeuf)
}
… dessert( Sorbet_aux_poires)
{e=Artichauts_Melanie,p=Grillade_de_boeuf,d=Sorbet_aux_poires
Voir les commandes du debugger >, <, j.
6.6.2.5.
Informations annexes sur l'exécution
Pour détailler l'état du programme en cours d'exécution, sur un but particulier, on peut se poser les questions : où en est-on dans l'exécution du programme? Et quelle règle essaie-t-on d'effacer pour ça?
Sur chaque point d'arrêt, le debugger permet de situer le but appelé par rapport à l'arbre de résolution et par rapport à la base de règles.
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 15
Quelle est la branche courante de l'arbre de résolution?
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^ titi / 1, rule number 1
^^^^^^^^ toto / 2, rule number 1
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
Quelle est la position du but dans le programme?
---> repas / 3, rule number 1, goal number 3 in queue
En fait, la branche courante de la résolution est donnée par l'état de la pile de récursion. L'optimisation de l'appel terminal pratiquée par la machine Prolog, ne permet pas de visualiser les règles pour lesquelles le but en cours d'exécution est le dernier de la queue. Par exemple :
> repas(e,p,d);
CALL: repas( v156, v191, v226)
DBG: s ici la pile est vide, puisque repas n'est pas encore installé.
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
DBG:
CALL: hors_d_oeuvre( v156)
DBG: s ici elle contient repas, puisque c'est le but appelant.
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^ repas / 3, rule number 1
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
DBG:
CALL: plat( v191)
DBG: s ici aussi, puisque plat et hors_d_oeuvre sont de même profondeur.
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^ repas / 3, rule number 1
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
DBG:
CALL: viande( v191)
DBG: s ici plat n'apparait pas puisque viande est son appel terminal.
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^ repas / 3, rule number 1
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
DBG:
CALL: dessert( v226)
DBG: s
^^^^^^^^^^^^^^^^TOP^^^^^^^^^^^^^^^^^^
^^^^^^^^^^^^^^^BOTTOM^^^^^^^^^^^^^^^^
DBG: ici repas n'apparait plus puisque dessert est son appel terminal.
Enfin, pour avoir accès au plus grand nombre d'informations, il est possible d'ouvrir une session Prolog. Ainsi, il est possible de vérifier les effets de bords du programme, de relancer une partie du programme, de lancer un programme annexe, de vérifier la base de règles, de consulter l'occupation des piles, … .
A l'ouverture de la session, le prompt de la ligne de commande est affiché dans la console et l'utilisateur peut entrer n'importe quel but Prolog. A la fermeture de la session (par l'effacement de quit par exemple) la mise au point continue où elle en
était. Il faut noter que les effets de bord de la session sont gardés: affectations, ajout/suppression de règles, ouverture/fermeture de fichier…
©PrologIA
R 6 - 16
Manuel de Référence
Par exemple, l'exécution de repas(e,Poulet,d)
provoque un échec. Mettons au point :
> repas(e,Poulet,d);
CALL: repas( v156, Poulet, v313)
DBG:
CALL: hors_d_oeuvre( v156)
DBG:
CALL: plat( Poulet)
DBG:
CALL: viande( Poulet)
DBG:
RECALL(2): plat( Poulet)
DBG:E pourquoi viande(Poulet) a échoué?
on ouvre une session,
> list(viande/1); le prompt Prolog apparait, viande(Grillade_de_boeuf) -> ; viande(Poulet_au_tilleul) -> ;
{}
> quit;
Elapsed time: 19s
Goodbye...
on consulte la base de règles, on termine la session,
DBG: w on est de retour sous le debugger!
---> plat / 1 , rule number 2, on backtracking
DBG: g
>
Voir les commandes du debugger s, w, E.
6.6.2.6.
Configuration
Comme nous l'avons déjà vu précédemment, il est possible de définir les comportements du debugger. L'ensemble des paramètres de comportement est appelé la configuration.
Certains paramètres de la configuration peuvent être précisés au lancement de l'outil, ils seront valides durant la session de mise au point (c'est à dire tant qu'on n'a pas désactivé l'outil ou tant qu'on ne l'a pas ré-activé avec d'autres paramètres) tant qu'une commande ne les modifie pas.
Les comportements paramétrables sont :
à l'activation ou sous l'interpréteur de commande du debugger : la progression dans le code, le moment d'impression des arguments, sous l'interpréteur de commande du debugger uniquement : la présentation des informations, dont : un paramètre d'indentation des messages, un paramètre de précision ou profondeur d'impression, le choix des informations : sur les erreurs, entre deux points d'arrêt, pendant la trace.
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 17
Une configuration standard est prédéfinie. Elle comprend : arrêt sur le prochain but, impression avant unification, aucune indentation, impression des termes par out en profondeur 4, impression d'un message et de la pile de récursion sur les erreurs.
Des commandes de l'outil de mise au point permettent de connaître sa configuration et toute autre information relative à la mise au point : l'état des options, la liste des points d'arrêt actifs, la liste des prédicats non développés en trace, la liste des commandes de l'outil.
Voir les commandes du debugger S, b, j, h et la règle prédéfinie show_spy.
6.6.3. Activation d'un mode de mise au point
L'outil de mise au point est activé dès l'effacement de l'un des prédicats prédéfinis
trace/0, trace/1, debug/0, debug/1 ou debug/2. Il est désactivé par l'effacement de l'un des prédicats prédéfinis no_trace/0 ou no_debug/0.
Un drapeau permet de définir la configuration de démarrage. Il vaut la somme des valeurs choisies parmi :
1 arrêt sur le premier appel de but.
2 arrêt sur le premier point d'arrêt fixe.
8 Option impression après unification validée
16 Option impression avant unification validée
Un drapeau égal à 0 correspond à la configuration standard prédéfinie.
debug(n) ou
debug(n, f)
sont les prédicats généraux d'activation du debugger. n doit être un entier connu au moment de l'appel. Il précise la configuration de démarrage, telle qu'elle a été définie ci-dessus. Quand n vaut 0, cela correspond à la configuration prédéfinie standard. f est un nom de fichier dans lequel seront redirigées les impressions du debugger. Le fichier est fermé à l'exécution d'un prédicat de désactivation de l'outil de mise au point. Si les impressions de mise au point étaient déjà redirigées, le précédent fichier est fermé pour être remplacé par f.
debug ou
debug(f)
sont les prédicats de réactivation du debugger. Ils ne modifient pas la configuration en place. f est un nom de fichier dans lequel seront redirigées les impressions du debugger. Le fichier est fermé à l'exécution d'un prédicat de désactivation de l'outil de mise au point. Si les impressions de mise au point étaient déjà redirigées, le précédent fichier est fermé pour être remplacé par f.
©PrologIA
R 6 - 18
Manuel de Référence
trace ou
trace(f)
sont des prédicats particuliers du debugger. Ils l'activent dans une configuration précise, celle du mode trace, représentée par le drapeau 19. f est un nom de fichier dans lequel seront redirigées les impressions du debugger.
Le fichier est fermé à l'exécution d'un prédicat de désactivation de l'outil de mise au point. Si les impressions de mise au point étaient déjà redirigées, le précédent fichier est fermé pour être remplacé par f.
no_trace ou
no_debug
sont des prédicats de désactivation de l'outil de mise au point, quel que soit son mode, sans altérer la configuration en place.
6.6.4. Gestion des points d'arrêt
Les règles prédéfinies qui permettent de manipuler les points d'arrêt sont:
spy(i/a)
Place un point d'arrêt sur l'entrée de la règle de nom i et d'arité a. Ce point d'arrêt n'est pris en compte que lorsque le debugger est activé avec un mode le permettant.
no_spy(i/a)
Enlève tout point d'arrêt placé sur la règle de nom i et d'arité a.
show_spy(l)
Unifie l avec la liste des primitives sur lesquelles un point d'arrêt est actif. Les primitives sont mentionnées sous la forme habituelle i/a avec i son identificateur d'accès et a son arité.
6.6.5. Commandes du mode interactif
A chaque point d'arrêt, le debugger imprime la séquence d'invite "DBG:" pour indiquer son attente d'une commande utilisateur. La frappe d'un retour chariot seul, noté RC dans ce chapitre, correspond à la commande par défaut step du mode interactif. Les autres commandes se terminent par un retour chariot.
Les commandes disponibles sont:
RC (step) Continue jusqu'au prochain appel de règle.
a
(abort program) Génère une interruption utilisateur.
b
(breakpoints) Affiche les points d'arrêt actifs. Voir aussi le prédicat show_spy.
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 19
e
(end debugging and go) Provoque la terminaison du mode debug et poursuit l'exécution.
f
E
(Execute) Empile une session Prolog.
(fail) Provoque un échec sur le but affiché.
g
(go to spy) Continue sans impression jusqu'au prochain point d'arrêt fixe.
G entier
(Go to end) Continue jusqu'à la fin du programme en imprimant seulement les points d'arrêt fixes si entier vaut 0. Si entier est différent de 0, imprime aussi les buts figurant dans la queue des points d'arrêt fixes.
h
(help) Liste les commandes disponibles.
i entier
(indent) La valeur de entier définit la marge, en nombre de caractères pour l'impression.
j
(jump) Donne la liste des règles dont on ignore le corps, en mode trace.
l entier
(length) La valeur de entier définit la longueur de la ligne pour les sorties.
m entier
(mode) La valeur de entier permet de choisir le mode d'affichage des buts
Prolog:
0
1
[2, 1000]
> 1000
Afficher sous la forme: identificateur/arité.
Affichage par le programme de dessin d'arbres.
Affichage en profondeur limité par entier.
Affichage complet du terme.
n
(next) Arrêt sur le prochain but qui n'est pas un sous but.
N
(Next while tracing) Arrêt sur le prochain but qui n'est pas un sous but, en imprimant les informations de l'exécution de la portion de programme, selon les options courantes choisies. L'effet de la commande > est ignoré dans ce cas.
p booléen
(print before unification) L'impression des buts avant unification est activée si
booléen vaut 1 ou désactivée si booléen vaut 0. Si booléen n'est pas mentionné, il équivaut à 0.
P booléen
(Print after unification) L'impression des buts après unification est activée si
booléen vaut 1 ou désactivée si booléen vaut 0. Si booléen n'est pas mentionné, il équivaut à 0.
©PrologIA
R 6 - 20
Manuel de Référence s q
(quit) Quitte Prolog, et retourne au niveau système hôte.
(stack) Affiche la pile Prolog des règles en cours d'exécution.
s 0 Permet d'éliminer l'impression du message et de la pile Prolog lors d'une erreur. s 1 la rétablit.
t
S
(State) Affiche les options courantes.
(trace to spy) Continue jusqu'au prochain point d'arrêt fixe, en imprimant les informations de l'exécution de la portion de programme, selon les options courantes choisies.
T
(Trace to end) Continue jusqu'à la fin du programme, en imprimant les informations d'exécution, selon les options courantes choisies.
w
(where) Affiche la position du but courant dans le programme.
+ ident/arité
Met un point d'arrêt sur le paquet de règles d'identificateur d'accès ident et d'arité arité. Voir aussi le prédicat spy.
- ident/arité
Supprime tout point d'arrêt sur le paquet de règles d'identificateur d'accès
ident et d'arité arité. Voir aussi le prédicat no_spy.
- a Permet de supprimer tous les points d'arrêt en une seule commande.
> ident/arité
Indique que le prédicat d'identificateur d'accès ident et d'arité arité ne devra pas être développé en trace.
< ident/arité
Annule l'effet de la commande inverse (>) sur le prédicat d'identificateur d'accès ident et d'arité arité.
< a Permet d'annuler l'effet de toutes les commandes inverses (>) qui ont eu lieu sur des prédicats.
Les points d'arrêt fixes, les prédicats à ne pas développer en trace, le mode d'impression et la définition de la marge, sont permanents. Ils ne sont pas modifiés par une activation spécifique ou par défaut de l'outil. Ils ne peuvent être modifiés ou supprimés qu'explicitement.
6.6.6. Exemple
A titre d'illustration, intéressons nous au programme d'exemple des menus livré dans le kit. Les commentaires de l'exécution sont donnés en italique.
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 21
On vérifie les règles chargées, puis on se place en mode debug. Enfin, on lance le but dif(d, Sorbet_aux_poires) balanced_meal( Truffes_sous_le_sel, p, d)
.
Ce qui est en gras est entré par l'utilisateur. Les lignes données par l'utilisateur doivent être terminées par un retour-chariot que nous n'indiquons pas, sauf dans le cas d'une ligne vide notée RC.
> dictionary;
DICTIONARY CONTENT OF "" balanced_meal / 3 calories / 2 dessert / 1 fish / 1 hors_d_oeuvre / 1 main_course / 1 meal / 3 meat / 1 smaller / 2 sumof / 4 value / 4
{}
> debug dif(d, Sorbet_aux_poires)
balanced_meal(Truffes_sous_le_sel,p,d);
CALL: dif( v254, Sorbet_aux_poires)
DBG: RC
CALL: balanced_meal( Truffes_sous_le_sel, v623, v743)
On ajoute à la configuration par défaut l'impression après unification et une indentation.
DBG: P1
DBG: i5
On vérifie l'état des options.
DBG: S
Print after unification
Print before unification
Print mode = out, depth: 4
Errors are printed
Indentation= 5
On poursuit.
DBG: RC
CALL: meal( Truffes_sous_le_sel, v623, v743)
C'est un prédicat important, on y met un point d'arrêt fixe et on vérifie les points d'arrêt fixes actifs.
DBG: +meal/3
DBG: b
meal/3
On poursuit.
DBG: RC
meal( Truffes_sous_le_sel, v623, v743)
CALL: hors_d_oeuvre( Truffes_sous_le_sel)
DBG: RC
hors_d_oeuvre( Truffes_sous_le_sel)
CALL: main_course( v623)
C'est un prédicat important, on y met un point d'arrêt fixe et on vérifie les points d'arrêt fixes actifs.
DBG: +main_course/1
DBG: b
main_course/1
©PrologIA
R 6 - 22
Manuel de Référence
meal/3
On poursuit.
DBG: RC
main_course( v623)
CALL: meat( v623)
DBG: RC
meat( Grillade_de_boeuf)
CALL: dessert( v743)
DBG: RC
RECALL(2): dessert( v743)
DBG: RC
dessert( Fraises_chantilly)
CALL: value( Truffes_sous_le_sel, Grillade_de_boeuf,
Fraises_chantilly, v817)
On ne veut pas s'arrêter dans ce prédicat, mais voir ce qui s'y passe.
DBG: N
value( Truffes_sous_le_sel, Grillade_de_boeuf,
Fraises_chantilly, v817)
CALL: calories( Truffes_sous_le_sel, v828)
calories( Truffes_sous_le_sel, 212)
CALL: calories( Grillade_de_boeuf, v833)
calories( Grillade_de_boeuf, 532)
CALL: calories( Fraises_chantilly, v838)
calories( Fraises_chantilly, 289)
CALL: sumof( 212, 532, 289, v817)
Les expressions arithmétiques ont été optimisées à la compilation.
add
add
sumof( 212, 532, 289, 1033)
CALL: smaller( 1033, 800)
DBG: N
inf
RECALL(3): dessert( v743)
DBG: RC
dessert( Melon_en_surprise)
CALL: value( Truffes_sous_le_sel, Grillade_de_boeuf,
Melon_en_surprise, v817)
On vérifie la position du prédicat.
DBG: w
---> balanced_meal / 3 , rule number 1, goal number 2 in queue
Pour la suite, le détail du prédicat n'est pas intéressant, on supprime son développement et on vérifie la liste des prédicats dans ce cas.
DBG: >value/4
DBG: j
value/4
On poursuit.
DBG: n
value( Truffes_sous_le_sel, Grillade_de_boeuf,
Melon_en_surprise, 866)
CALL: smaller( 866, 800)
DBG: >smaller/2
DBG: j
smaller/2
value/4
DBG: n
RECALL(2): dessert( v743)
A!ociation
Prolog
HERITAGE
©PrologIA
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 23
On souhaite avoir la trace jusqu'au prochain point d'arrêt avec seulement l'impression après unification, on désactive donc l'impression avant unification.
DBG: p0
DBG: t
dessert( Fraises_chantilly)
value( Truffes_sous_le_sel, Poulet_au_tilleul,
Fraises_chantilly, 901)
RECALL(3): dessert( Melon_en_surprise)
value( Truffes_sous_le_sel, Poulet_au_tilleul,
Melon_en_surprise, 734)
smaller( 734, 800)
{d=Melon_en_surprise,p=Poulet_au_tilleul}
RECALL(2): main_course(v165)
. DBG: p1
On se trouve arrêté sur un point d'arrêt fixe, on s'intéresse aux prédicats importants (ils ont un point d'arrêt fixe) jusqu'à la fin.
DBG: +meat/1
DBG: +fish/1
DBG: b
fish/1
main_course/1
meal/3
meat/1
DBG: G
main_course( v623)
CALL: fish( v623)
fish( Bar_aux_algues)
{d=Fraises_chantilly,p=Bar_aux_algues}
{d=Melon_en_surprise,p=Bar_aux_algues}
RECALL(2): fish( v623)
fish( Chapon_farci)
{d=Fraises_chantilly,p=Chapon_farci}
{d=Melon_en_surprise,p=Chapon_farci}
>
6.7. Modification et visualisation de l'état courant
alloc alloc/12
Décrit l'état des piles Prolog. La version sans argument écrit les valeurs courantes sur la sortie courante. Les arguments s'il sont présents, sont unifiés respectivement avec l'espace occupé et l'espace libre de:
1,2: espace du code,
3,4: pile de copie des structures (heap),
5,6: pile des environnements et variables locales (stack),
7,8: pile de restauration (trail),
9,10: espace du dictionnaire,
11,12: aucun espace.
©PrologIA
R 6 - 24
Manuel de Référence edinburgh
Permet de passer en mode Edinburgh lorsque l'on est en mode Prolog II : change de syntaxe, ajoute des règles prédéfinies, ajoute et modifie des opérateurs. Cette primitive provoque le chargement du module edinburg.mo.
get_option(o,x)
Permet de connaître la valeur d'une option de comportement dans la session. o doit être une chaîne d'un caractère représentant l'option. x est unifié avec une chaîne d'un caractère représentant la valeur de l'option. La signification des caractères est celle définie par les conventions de l'option de la ligne de commande -f (cf. §U2.3). Par exemple pour connaître la syntaxe des réels choisie pour la session:
> get_option("r",x);
{x="P"}
prologII
Permet de passer en mode Prolog II lorsque l'on est en mode Edinburgh : change de syntaxe, modifie les opérateurs, supprime les règles prédéfinies spécifiques Edinburgh.
prologIIE
Permet de passer en mode Prolog II lorsque l'on est en mode Edinburgh, en gardant les règles prédéfinies spécifiques Edinburgh : change de syntaxe, modifie les opérateurs.
state
Affiche l'état courant des piles, et le nom des modules se trouvant en mémoire.
statistics statistics/12
Permet de visualiser les valeurs maximales atteintes durant une session dans les espaces Prolog. La mémorisation de ces valeurs est effectuée en mode
debug uniquement. Si debug n'a jamais été effacé avant l'appel à statistics, les valeurs affichées ne sont pas significatives. Les arguments ont la même signification que pour le prédicat alloc.
set_options(o)
Permet de changer les options ayant pu être définies au lancement par l'option
-f de la ligne de commande, sans sortir de Prolog. o est une chaîne de caractères. Exemple pour passer en syntaxe de variable Edinburgh et en syntaxe de réels standard:
> set_options("vErS");
version(o)
Permet d'obtenir la version courante de Prolog. Par exemple, si la version courante est la version 3.1,
> version(o);
{o=301}
©PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
L'environnement
R 6 - 25
6.8. Gestion automatique des espaces et des piles
Le fonctionnement d'une machine suppose des piles, pour gérer l'exécution, et des espaces pour stocker les structures du programme.
Le système Prolog II+, qui est une machine virtuelle, possède trois piles :
- pile de récursion (stack) : qui contient les environnements successifs des appels de la démonstration en cours;
- pile de copie (heap) : qui contient une copie des structures de la démonstration en cours;
- pile de restauration (trail) : qui contient la mémorisation des valeurs des arguments, pour le backtracking; et deux espaces pour les structures internes :
- espace pour le code : qui contient toutes les règles compilées et les données statiques de tous les modules;
- espace pour le dictionnaire : qui contient tous les identificateurs et les accès aux règles créés durant la session.
Le système Prolog II+ comporte un mécanisme de récupération et tassage des piles et des espaces, ainsi qu'un mécanisme de réallocation.
Pendant les opérations qui consomment les piles ou les espaces (assert, insert,
def_array, récursivité non terminale…), ces piles ou espaces peuvent arriver à saturation. Le mécanisme de récupération d'espace et de tassage est alors déclenché automatiquement. Si malgré cela, la place libre restant dans la pile ou l'espace est toujours insuffisante, le mécanisme de réallocation est à son tour déclenché automatiquement. Il est chargé de réallouer la pile ou l'espace en cause, avec une taille supérieure de 25% à ce qu'elle était. Ce pourcentage est celui par défaut. Il est possible de le modifier à l'aide d'une option sur la ligne de commande au démarrage de Prolog (cf U2.3).
Il est possible de déclencher explicitement un des deux mécanismes sur une pile ou un espace, à l'aide des prédicats gc et realloc.
gc(x)
déclenche la récupération et le tassage de l'espace désigné par x. x peut prendre les valeurs suivantes:
:code
pour l'espace du code,
:dictionary pour l'espace du dictionnaire,
:stacks
pour les piles (qui ne peuvent pas être dissociées pour cette opération).
©PrologIA
R 6 - 26
Manuel de Référence
N.B. : Lorsque le récupérateur de l'espace du code est activé, toutes les règles en cours d'utilisation dans l'effacement courant sont considérées comme devant être conservées, même si elles ont été précédemment supprimées et sont donc inaccessibles pour une nouvelle exécution.
N.B. : Le récupérateur d'espace doit déterminer les objets inutiles pour pouvoir réutiliser leur place. Les structures succeptibles d'être manipulées depuis un langage externe et sur lesquelles le récupérateur d'espace peut agir, sont les identificateurs
Prolog. Pour permettre à Prolog de savoir si un identificateur est toujours utile et pour éviter à l'utilisateur de continuer à manipuler une représentation éventuellement obsolète, l'utilisateur doit préciser à Prolog s'il utilise ou pas un identificateur particulier depuis l'extérieur, afin que le récupérateur d'espace ne le supprime pas.
Ceci peut être fait grâce aux fonctions set_permanent_symbol et
reset_permanent_symbol (cf. Chapitre 7 de ce manuel).
realloc(x,y)
déclenche la réallocation de l'espace désigné par x, d'une taille réajustée par le coefficient y. x peut prendre les valeurs :code, :dictionary, :stack, :heap, trail, selon qu'il s'agisse respectivement : du code, du dictionnaire, de la pile de récursion, de la pile de copie ou de la pile de restauration. y est un entier, il indique le pourcentage d'augmentation (s'il est positif) ou de diminution (s'il est négatif) de la taille précédente.
A!ociation
Prolog
HERITAGE
©PrologIA
Öffentlicher Link aktualisiert
Der öffentliche Link zu Ihrem Chat wurde aktualisiert.