5. Les entrées / sorties. PrologIA HERITAGE II+

PDF

Dokument

A!ociation

Prolog

HERITAGE

5. Les entrées / sorties

5.0. Généralités

5.1. Entrées

5.2. Sorties

5.3. Chargement et adaptation du module de dessin

5.4. Déclaration d'opérateurs

Tous les organes d'entrée / sortie (clavier, écran, fichiers, fenêtres, etc…) utilisés par un programme Prolog II+ y sont représentés par des entités appelées unités

d'entrée/sortie. La représentation écrite d'une telle unité est une chaîne de caractères 1 ; le cas échéant, cette chaîne représente aussi une information identifiant l'unité vis-à-vis du système d'exploitation : nom de fichier, etc…

A tout moment, le système Prolog II+ «connaît» un certain nombre d'unités d'entrée

/ sortie : ce sont les unités qui ont été précédemment ouvertes et qui n'ont pas encore

été fermées. Les descripteurs de ces unités sont rangés dans une sorte de pile : l'unité qui est au sommet s'appelle l'unité courante. En principe, toutes les opérations d'entrée / sortie s'effectuent sur l'unité courante correspondante. Au lancement, une unité d'entrée (appelée console) et une unité de sortie (appelée également console) sont ouvertes automatiquement par le système et sont les unités courantes; habituellement, ces unités sont associées au clavier et à l'écran de l'ordinateur ou du terminal depuis lequel Prolog a été lancé.

Changer d'unité (i.e.: effacer input(f) ou output(f)) ne ferme pas «physiquement» l'unité courante ni ne change son état, mais ouvre -si nécessaire- une nouvelle unité et la met au sommet de la pile, de façon à pouvoir restaurer l'unité précédente, à la fermeture de cette nouvelle unité. Le nombre d'unités pouvant être ouvertes simultanément est dépendant de la machine hôte.

5.0. Généralités

Les unités d'entrée / sortie créées ont un type bien défini, ainsi qu'un mode d'ouverture. Les différents types possibles sont :

- :console pour l'unité créée automatiquement par Prolog au démarrage.

- :text pour un fichier disque au format texte.

- :binary pour un fichier disque au format binaire.

- :memory_file pour un fichier mémoire décrit ci après.

- :unix_pipe pour un "tube" de communication inter-processus (UNIX).

- :graphic_area, :tty_area, :edit_area pour des unités graphiques.

Les unités fenêtres peuvent aussi être représentées par des entiers.

©PrologIA

R 5 - 2

Manuel de Référence

Les différents modes d'ouverture possibles sont :

:read pour la lecture.

:write pour l'écriture. Si l'objet physique (un fichier disque par exemple) du même nom existe déjà, son contenu sera effacé et remplacé par les sorties qui seront demandées.

:append pour l'écriture. Ce mode est spécifique aux fichiers. Si un objet physique associé existe déjà, il est ouvert et les futures écritures y seront ajoutées en fin. Ce mode d'ouverture peut être défini par une convention de nommage de l'unité, dont le nom doit dans ce cas se terminer par "+". Le fichier associé à l'unité est alors celui de nom donné, après avoir ôté le "+".

Par exemple output("file+") va provoquer l'ouverture du fichier de nom "file" en mode append.

Certaines unités peuvent être ouvertes à la fois en lecture et en écriture. C'est le cas des types :console, :tty_area , :edit_area, et :memory_file.

memory_file(s) memory_file(s,n)

Crée une unité de type "fichier mémoire" de nom s. Son tampon de caractères a une longueur de 400 caractères pour la première forme du prédicat. En utilisant la deuxième forme, le tampon sera de longueur n ou de la valeur la plus proche, sachant que la taille minimale allouée est de 400 caractères et la taille maximale allouée est de 32K caractères. Cette unité peut être utilisée en entrée et en sortie. Elle peut être en même temps unité courante d'entrée et unité courante de sortie. Si le tampon est trop petit pour les opérations d'écritures qui y sont faites, il est automatiquement doublé de taille, sans dépasser les 32K caractères. L'unité sera fermée physiquement quand elle aura été fermée à la fois en lecture et en écriture. Cette unité peut être utilisée au même titre que les fichiers.

Les types et les modes d'ouverture des unités peuvent être obtenus par le prédicat :

current_file(x) current_file(x,t,m)

Unifie successivement x avec les noms des unités ouvertes en lecture et/ou en

écriture, t avec le type de cette unité, et m avec le mode d'ouverture.

A!ociation

Prolog

HERITAGE

5.1. Entrées

Le tampon de caractères standard pour une unité d'entrée fourni par Prolog est limité à 400 caractères. S'il arrive qu'une ligne soit plus longue, Prolog se comporte comme s'il y avait un espace après le 400-ième caractère. Le reste de la ligne est lu après épuisement des 400 caractères précédents.

Il est conseillé de manipuler des lignes moins longues. Se rappeler que :

- le Retour Chariot sera lu au même titre que le caractère blanc par les primitives qui commencent par lire tous les espaces,

©PrologIA

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 3

- les espaces et les tabulations peuvent apparaître partout entre les unités lexicales,

- les chaînes, les identificateurs, les entiers et la mantisse des réels peuvent s'écrire sur plusieurs lignes, en masquant le Retour Chariot par le caractère '\', si l'option d'interprétation du '\' est active (cf. U2.3.).

5.1.1. Règles pour l'entrée.

eol

Test de fin de ligne en entrée.

Teste si une fin de ligne a été atteinte; plus précisément : si le prochain caractère qui sera lu est une marque de fin-de-ligne, alors eol s'efface; sinon, l'effacement de eol échoue.

Exemple :

> in_char'(c) eol;

a<CR>

{c="a"}

> in_char'(c) eol;

a<space><CR>

eof

Test de fin d'entrée.

Teste s'il existe encore des caractères en entrée sur l'unité courante. Autrement dit, teste si la prochaine lecture va provoquer l'erreur 104: FIN DE FICHIER.

Si ce n'est pas le cas, l'effacement de eof échoue. Ne peut évidemment jamais s'effacer sur la "console" ou dans une fenêtre TTY, puisque ce sont des unités en mode terminal, qui ont toujours des caractères, éventuellement après saisie.

Exemple :

> input("fichier_vide") eof input("console");

{}

in_char(t)

Lecture d'un caractère.

Lit le prochain caractère, le transforme en une chaîne de longueur 1 et essaie de l'unifier avec t.

Remarque: le caractère fin de ligne, s'il est assimilé à un espace pour d'autres primitives qui analysent les caractères lus, vaudra bien pour cette primitive

"\n".

Remarque: toute commande (suite de buts) se termine au ";". Lorsque in_char est lancé sur la ligne de commande, le premier caractère lu est le caractère qui suit immédiatement le ';'. Il s'agit souvent de : fin de ligne.

Exemple :

> in_char(c);

{c="\n"}

> clear_input in_char(c);

a<CR>

{c="a"}

©PrologIA

R 5 - 4

Manuel de Référence in_char'(t)

Lecture d'un caractère non blanc.

Lit tous les caractères blancs et se comporte comme in_char(t).

Exemple:

>in_char'(x) in_char(y) in_char'(z) in_char(t);

ab c d

{x="a",y="b",z="c",t=" "}

next_char(t)

Essaie d'unifier le prochain caractère à l'entrée avec t sans le lire vraiment.

next_char'(t)

Lit tous les caractères blancs s'il y en a et ensuite se comporte comme

next_char(t).

Exemple:

>next_char'(x) in_char(y); abc

{x="a",y="a"}

inl(s) inl(s, n)

Lecture d'une ligne.

Lit toute la fin de la ligne courante et l'unifie, en tant que chaîne de caractères, avec s. n est unifié avec le rang de la ligne lue, dans son unité. n est beaucoup plus significatif pour les fichiers, voire les fenêtres EDIT. Dans la "console" ou les fenêtres TTY, les lignes sont divisées en deux groupes : lignes d'entrée et lignes de sortie. n est alors le rang à l'intérieur d'un de ces groupes.

Exemple:

> clear_input inl(s);

Maitre corbeau, sur un arbre perche

{s="Maitre corbeau, sur un arbre perche"}

in(t, c) in(t, D, c)

Lecture d'un terme Prolog.

Lit la plus grande suite x de caractères qui constituent un terme ou le début d'un terme. Si x est l'expression d'un terme, on essaie d'unifier ce dernier avec

t. Si x n'est pas un terme, une erreur se produit. Tous les caractères blancs qui suivent x sont lus; c est unifié avec la première unité lexicale lue, ne faisant pas partie de x. D est unifié avec le dictionnaire des variables du terme, c'est-àdire une liste de doublets correspondant aux variables de t. Chaque doublet contient la chaîne de caractères qui est le nom originel de la variable et la variable en question.

Exemple:

>in(t, c);

ceci.est.un.terme;

{t=ceci.est.un.terme, c=";"}

>in(t, D, c);

A!ociation

Prolog

HERITAGE

©PrologIA

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 5

aa(x, bb(y_n1',x));

{t=aa(v129, bb(v163,v129)),

D=<"x", v129>.<"y_n1'",v163>.nil, c=";"}

Note: La lecture d'une unité en avance est ici indispensable à cause des opérateurs.

in_integer(t)

Lit d'abord tous les caractères blancs, puis essaie de lire un entier sur l'unité courante. Si l'objet lu n'a pas la syntaxe d'un entier, alors rien n'est lu et

in_integer échoue. Sinon t est unifié avec l'entier qui a été lu.

Exemple:

>in_integer(i) in_char(c) in_integer(j);

-123+456

{i=-123,c="+",j=456}

ATTENTION : l'écriture des entiers et réels pouvant se faire sur plusieurs lignes, à l'aide de "\<return>" (si l'option d'interprétation du '\' est active (cf.

U2.3.)), si l'objet en entrée n'est pas un entier, mais un réel écrit sur plusieurs lignes, Prolog ne peut pas restaurer les lignes précédant la dernière.

in_real(t)

Lit d'abord tous les caractères blancs, puis essaie de lire un réel sur l'unité courante. Si l'objet lu n'a pas la syntaxe (définie par l'option courante) d'un réel, alors rien n'est lu et in_real échoue. Sinon t est unifié avec le réel qui a

été lu.

> in_real(x) in_char(c) in_real(y);

-123e+4,54.63e0

{x=-1.230000000000000e+06, c=",", y=5.463000000000000e+01}

ATTENTION : l'écriture des entiers et réels pouvant se faire sur plusieurs lignes, à l'aide de "\<return>" (si l'option d'interprétation du '\' est active (cf.

U2.3.)), si l'objet en entrée n'est pas un réel, mais un entier écrit sur plusieurs lignes, Prolog ne peut pas restaurer les lignes précédant la dernière.

in_double(t)

Identique à in_real(t).

in_string(t)

Lit d'abord tous les caractères blancs, puis essaie de lire une chaîne Prolog. Si l'objet n'a pas la syntaxe d'une chaîne, alors rien n'est lu et in_string échoue.

Sinon t est unifié avec la chaîne lue. Attention : il s'agit bien d'un terme Prolog

de type chaîne (i.e.: avec les quotes) et non de «n'importe quoi, considéré comme une chaîne».

Exemple:

>in_string(s) in_char(c);

"Hello !";

{s="Hello !", c=";"}

©PrologIA

R 5 - 6

Manuel de Référence in_ident(t)

Lit d'abord tous les caractères blancs, puis essaie de lire un identificateur

Prolog. Si l'objet lu n'a pas la syntaxe (définie par l'option courante) d'un identificateur, alors rien n'est lu et in_ident échoue. Sinon t est unifié avec l'identificateur qui a été lu.

Exemple:

lire(entier(n)) -> in_integer(n) !; lire(ident(i)) -> in_ident(i) !; lire(chaine(s)) -> in_string(s) !; lire(caractere(c)) -> in_char(c);;

>lire(x1) lire(x2) lire(x3) lire(x4) lire(x5) lire(x6) …; aa := bb * 123 …

{x1=ident(aa),x2=caractere(":"),x3=caractere("="), x4=ident(bb),x5=caractere("*"),x6=entier(123), … }

in_word(t1, t2)

Lit tous les caractères blancs, puis lit le mot le plus long, le transforme en une chaîne et essaie d'unifier cette chaîne avec t1. Un mot est soit :

(1) une suite de lettres

(2) une suite de chiffres

(3) tout caractère qui n'est ni un blanc, ni une lettre, ni un chiffre.

Dans le cas (1), t2 est l'identificateur correspondant à t1 si cet identificateur est déjà connu, ou nil s'il s'agit de sa première apparition. Dans ce dernier cas, l'identificateur n'est pas créé dans le dictionnaire.

Dans le cas (2), t2 est l'entier correspondant à t1.

Dans le cas (3), t2 = t1.

>in_word(x, y);

toto

{x="toto", y=nil}

>in_word(x, y);

insert

{x="insert", y=insert}

>in_word(x, y);

012345

{x="012345", y=12345}

>in_word(x, y);

{x="+", y="+"}

in_sentence(t1, t2)

Lit une phrase qui se termine par ".", "?", "!" ou tout autre caractère qui a été défini comme terminateur et met la phrase sous la forme de deux listes. t1 est la liste des unités lexicales constituant la phrase (les mots au sens de in_word) et t2 est la liste des atomes correspondants, comme pour in_word.

La liste des terminateurs de phrases peut être modifiée par les prédicats

add_sentence_terminator/1 et remove_sentence_terminator/1.

>in_sentence(x, y);

ceci est un string.

{x="ceci"."est"."un"."string".".".nil,

©PrologIA

A!ociation

Prolog

HERITAGE

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 7

y=nil.nil.nil.string.".".nil}

>in_sentence(x, y);

somme := 052345;.

{x="somme".":"."="."052345".";".".".nil,

y=nil.":"."=".52345.";".".".nil}

add_sentence_terminator(C)

Ajoute le caractère C dans la liste des terminateurs de phrases (initialement dotée des caractères ".", "?", et "!").

remove_sentence_terminator(C)

Enlève le caractère C de la liste des terminateurs de phrases. Provoque un

échec si ce caractère n'est pas dans cette liste.

read_unit(t, u)

Lecture d'une unité lexicale.

Lit une unité lexicale et unifie t avec son type (identificateur, nombre, etc…) donné par un nombre conventionnel, et u avec sa valeur.

Les unités lexicales de Prolog II+ sont décrites par la grammaire donnée au paragraphe 1.9. Relativement aux notations utilisées dans cette grammaire, le type t utilisé par read_unit est défini comme suit :

3 valeur de t catégorie lexicale

1 identifier separator 1 variable constant graphic_symbol valeur de u l'identificateur la chaîne correspondante la chaîne correspondante la constante la chaîne correspondante

Exemple:

> read_unit(t1,u1) read_unit(t2,u2) read_unit(t3,u3)

read_unit(t4,u4); x12 + :pi ,

{t1=3,u1="x12",t2=5,u2="+",t3=1,u3=pi,t4=2,u4=","}

> read_unit(t,u);

123

{t=4,u=123}

read_rule(t1,t2)

Lit sur l'unité d'entrée courante une règle Prolog, et unifie t1 avec la tête, et t2 avec la liste des termes de la queue.

Exemple:

> read_rule(t1,q1) read_rule(t2,q2);

tt(1,x) -> outl(x) fail; tt(2,x) -> !;

{t1=tt(1,v118),q1=outl(v118).fail.nil,

t2=tt(1,v228),q2='!'.nil}

separator est un séparateur syntaxique: voir § 1.2 de ce manuel.

©PrologIA

R 5 - 8

Manuel de Référence

sscanf

La fonction C sscanf est accessible depuis Prolog avec la primitive callC (voir

§ 7.7. de ce manuel).

> callC(sscanf("123","%lf",<"R",y>));

{y=1.230000000000000e+02}

> eq(f,"%x %o") callC(sscanf("12 12",f,<"I",x>,<"I",y>));

{x=18, y=10}

5.1.2. Modification de l'unité d'entrée.

Le nom des unités d'entrée, peut être soit une chaîne Prolog, soit un identificateur

Prolog, soit un entier. Toutefois, les fichiers et les fenêtres prédéfinies sont toujours désignés par des chaînes.

input(u) input(u,n)

L'unité dont le nom est u, devient l'unité d'entrée courante. Si cette unité ne figure pas parmi les unités ouvertes, alors son descripteur est créé et ajouté dans la pile des unités d'entrée ouvertes. Si l'unité est nouvelle, un fichier est recherché et ouvert. Un fichier de commandes ouvert par input peut lui-même contenir une commande input, la nouvelle unité courante est empilée audessus de la précédente. Dans la forme à deux arguments, n précise la taille, en nombre de caractères, du tampon de l'unité. Elle doit être comprise entre

400 et 32K. Si n n'est pas dans cet intervalle, la taille du tampon sera de la valeur la plus proche.

input_is(u)

Unifie u avec le nom de l'unité d'entrée courante.

close_input

L'unité courante est fermée (sauf s'il s'agit de la console ou d'une fenêtre) et son descripteur est enlevé du sommet de la pile des unités: l'unité précédente redevient unité courante.

close_input(u)

L'unité de nom u, qui doit figurer dans la liste des unités d'entrée ouvertes, est fermée (sauf s'il s'agit de la console ou d'une fenêtre) et son descripteur est enlevé de cette liste.

clear_input

Saute les caractères qui restent non lus sur la ligne courante d'entrée.

A!ociation

Prolog

HERITAGE

©PrologIA

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 9

5.2. Sorties

A travers les primitives out, outm et line, Prolog tient à jour un pointeur de ligne pour chaque unité de sortie. C'est l'effacement de la primitive line qui le réinitialise.

Ce pointeur permet de maintenir en interne, une représentation de ce qui se passe sur la ligne courante de l'unité. Il sert en particulier, à déterminer la place qui reste sur la ligne (la longueur de ligne est définie par set_line_width) et par conséquent sert à générer un passage à la ligne forcé.

L'utilisation de set_cursor n'agit pas sur ce pointeur de ligne, par conséquent la représentation de la ligne que se fait Prolog n'est plus exacte. Il peut arriver que des passages à la ligne forcés (\<return>) soient malvenus. Il est donc conseillé, pour

éviter cela, d'utiliser conjointement à set_cursor, les primitives outl et outml plutôt que les primitives out et outm. Ainsi le pointeur de ligne est constamment réinitialisé et la gestion de la présentation est totalement laissée à set_cursor. On notera que le comportement est le même, en faisant appel à des règles externes (C, Pascal, …) qui gèrent la présentation de l'écran.

5.2.1. Règles pour la sortie

beep

Génère une tonalité d'avertissement.

flush

Vide le tampon de caractères de l'unité courante de sortie, en envoyant tous les caractères en attente d'écriture sur l'unité physique associée.

out(t) outl(t)

Ecrit le terme t sur l'unité courante. Tout terme écrit avec out peut être relu avec in si l'option d'interprétation du caractère spécial «\» est active (cf. §2.3.

du manuel d'utilisation). Si le terme est plus long que la longueur restant sur la ligne courante, un retour chariot est inséré en respectant les principes suivants:

(1) Lorsqu'une chaîne ne peut être imprimée sur une seule ligne, elle est coupée à l'endroit requis par insertion d'un retour-chariot masqué (c'est-àdire précédé par le caractère «\»).

(2) Un nombre n'est pas coupé sauf si, tout seul, il est plus long que toute une ligne; dans ce cas il est coupé comme une chaîne.

(3) Un identificateur n'est pas coupé sauf si, tout seul, il est plus long que toute une ligne; dans ce cas il est coupé comme une chaîne.

L'écriture du terme se fait avec les conventions suivantes:

(1) Les listes sont imprimées en notation pointée pour la syntaxe Prolog II, en notation avec des crochets carrés pour la syntaxe Edinburgh ou si l'option "notation standard des réels" est activée.

©PrologIA

R 5 - 10

Manuel de Référence

(2) Si une chaîne contient un caractère non imprimable, celui-ci est écrit sous forme d'escape séquence imprimable (voir outm).

(3) Tout identificateur ne répondant pas à la syntaxe d'un identificateur est quoté.

(4) Le contexte courant d'exécution détermine les abréviations possibles pour les identificateurs.

outl(t) équivaut à la suite de buts out(t) line : lorsque le terme t a été écrit on produit le passage à la ligne suivante.

Exemple:

> out(1.Pierre."Salut!".nil);

1.Pierre."Salut!".nil{}

N.B. : Les accolades imprimées à la suite du terme indiquent la réussite de l'effacement du but out(1.Pierre."Salut!".nil). Une manière d'en empêcher l'impression consiste à faire échouer artificiellement cet effacement :

>out(1.Pierre."Salut!".nil) line fail;

1.Pierre."Salut!".nil

outm(s) outml(s)

Ecrit la chaîne s sur l'unité active de sortie, sans écrire les quotes et en interprétant correctement les caractères de formatage que s peut contenir (par exemple: \n). Si la chaîne est plus longue que la place restante sur la ligne en cours, alors elle est coupée par un retour chariot «masqué». Les caractères correspondant à un code ISO 8859-1 non imprimable sont envoyés sur l'unité courante de sortie sans transformation.

Exemple:

> out("\tBonjour!") line fail;

"\tBonjour!"

> outm("\tBonjour!") line fail;

Bonjour!

outml(s) équivaut à outm(s) line.

outm(s, n)

Ecrit n fois la chaîne s avec les mêmes conventions que ci-dessus.

Exemple :

>outm("-",40) line fail;

----------------------------------------

out_equ(t)

Ecrit le système minimal d'équations du terme t. Cette règle est beaucoup plus lente que out, mais factorise les sous-arbres et donne donc, entre accolades, une représentation plus compacte quand c'est possible.

A!ociation

Prolog

HERITAGE

©PrologIA

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 11

line

Va à la ligne.

page

Va à la page. Sur l'unité "console", l'écran est effacé et le curseur positionné en haut à gauche de l'écran. N'a pas d'effet dans l'environnement graphique.

paper

Provoque la copie de ce qui se passe à la console dans un fichier journal

(prolog.log par défaut).

no_paper

Annule l'effet de paper. Le fichier journal est fermé uniquement en fin de session. Un appel ultérieur à paper viendra ajouter des informations à la fin du fichier.

set_cursor(n1, n2)

Le curseur est positionné en (n1,n2) sur l'écran, n1 étant la coordonnée de la colonne et n2 celle de la ligne. (1,1) correspond au coin en haut à gauche de l'écran. On doit avoir :

1 ! n1 ! largeur de la ligne et 1 ! n2 ! nombre de lignes de l'écran.

N'a pas d'effet dans l'environnement graphique.

set_line_cursor(n)

Positionne le pointeur courant de caractères à la position n sur la ligne courante. Cela fournit une sorte de tabulation. set_line_cursor ne revient pas en arrière à partir de la position courante du pointeur. La position du premier caractère est 1.

sprintf

La fonction C sprintf est accessible depuis Prolog avec la primitive callC (voir

§ 7.7. de ce manuel).

> callC(sprintf(<"",x,80>,"valeur: %ld",200));

{x="valeur: 200"}

L'utilisation des primitives suivantes nécessite le chargement préalable du module de dessin d'arbres (voir § 5.3).

draw_equ(t)

Dessine le système minimal d'équations représentant un arbre fini ou infini t .

Pour utiliser cette primitive, il faut que le module de dessin d'arbres soit chargé.

©PrologIA

R 5 - 12

Manuel de Référence

> ... draw_equ(aa(bb(cc,dd),bb(cc,dd))) ...

+--^--+ v1026 v1026 v1026 = bb

+^-+

cc dd

{}

draw_tree(t)

Dessine l'arbre fini t sur l'écran (si le terminal a des possibilités graphiques, les symboles semi-graphiques sont utilisés). Pour utiliser cette primitive, il faut que le module de dessin d'arbres soit chargé.

> ... draw_tree(aa(bb(cc,dd),bb(cc,dd))) ...

+--^---+

bb bb

+^-+ +^-+

cc dd cc dd

{}

draw_mode(x)

Cette primitive, ainsi que la suivante concernent la manière dont les arbres sont dessinés. En effet, suivant le type d'écran certains caractères semi-graphiques sont utilisés pour obtenir des dessins d'arbres plus jolis. draw_mode(x) fournit dans x une chaîne correspondant au type d'écran utilisé. Les valeurs possibles de x sont dépendantes de la machine: "VT100", "GRAPHICS",

"TTY". "TTY" qui correspond à un écran sans possibilité graphique, existe sur toutes les machines. Pour utiliser cette primitive, il faut que le module de dessin d'arbres soit chargé.

set_draw_mode(x)

Permet de choisir le type d'écran utilisé pour le dessin des arbres. Les valeurs de x sont les mêmes que précédemment. Si vous voulez faire imprimer des arbres sur une imprimante classique, il faut se mettre en mode "TTY". Pour utiliser cette primitive, il faut que le module de dessin d'arbres soit chargé.

5.2.2. Modification de l'unité de sortie

Le nom des unités de sortie, peut être soit une chaîne Prolog, soit un identificateur

Prolog, soit un entier. Toutefois, les fichiers et les fenêtres prédéfinies sont toujours désignés par des chaînes.

A!ociation

Prolog

HERITAGE

©PrologIA

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 13

output(u) output(u,n)

L'unité de nom u devient l'unité courante de sortie. Si l'unité désignée par u ne figure pas déjà dans la liste des unités de sortie ouvertes, alors un descripteur pour l'unité est alloué et éventuellement un fichier est créé ayant le nom indiqué par u. Dans la forme à deux arguments, n précise la taille, en nombre de caractères, du tampon de l'unité. Elle doit être comprise entre 400 et 32K.

Si n n'est pas dans cet intervalle, la taille du tampon sera de la valeur la plus proche. Dans la forme à un seul argument, le tampon aura une taille de 400 caractères.

En aucun cas ces primitives ne créent une fenêtre ou un fichier mémoire, il faut utiliser pour cela les primitives spécifiques. Si u est une chaîne de caractères terminée par le signe "+", le fichier dont le nom est la chaîne privée de ce signe est alors ouvert en mode append, c'est à dire que si ce fichier existe déjà sur disque, les sorties qui suivront vont y être ajoutées en fin.

output_is(u)

Fournit dans u le nom de l'unité de sortie courante.

close_output

L'unité courante est enlevée du sommet de la pile des unités de sortie ouvertes.

Si elle correspond à un fichier, alors celui-ci est fermé.

close_output(u)

u est le nom d'une unité qui doit figurer dans la liste des unités de sortie ouvertes. S'il s'agit d'un fichier, il est fermé. Le descripteur de l'unité est enlevé de cette liste et détruit. En aucun cas cette primitive ne ferme une fenêtre, il faut utiliser pour cela les primitives spécifiques.

line_width(n)

Fournit dans n la longueur maximum actuelle des lignes de l'unité courante, définie par set_line_width.

set_line_width(n)

Permet de définir la longueur maximale des lignes de l'unité courante de sortie. n devient la nouvelle longueur de ligne de l'unité. Par défaut, la longueur maximale de la ligne est de 80 caractères. Dans tous les cas, elle est limitée à 400 caractères. Si aucun passage à la ligne suivante n'a été demandé, avant que la longueur maximum de la ligne ait été atteinte, Prolog le force, en insérant un <retour chariot> entre deux unités ou bien la séquence <\><retour chariot> à l'intérieur d'une unité.

echo

Active l'option qui provoque l'affichage sur l'unité "console" des caractères lus ou écrits sur une autre unité, de type fichier.

©PrologIA

R 5 - 14

Manuel de Référence no_echo

Annule l'effet de echo.

5.3. Chargement et adaptation du module de dessin

Le module Dessin ne figure pas dans l'état initial qui vous est livré. Vous pouvez l'inclure en chargeant le fichier binaire:

> load("dessin.mo");

Pour charger à partir du répertoire Prolog, taper la commande:

> getenv("PrologDir2",S)

conc_string(S,"dessin.mo",S1) load(S1);

Vous pouvez également recompiler le module source:

> insert("dessin.m2");

Ce fichier crée un nouveau module, Dessin, contenant le programme de tracé d'arbres et d'équations. Ceci rend disponible les règles suivantes (voir §5.2.1.):

draw_equ draw_tree draw_mode set_draw_mode

gr_tree_click si le mode graphique est activé.

S'agissant d'un module de dessin il faut, bien entendu, y incorporer certains renseignements sur les possibilités semi-graphiques des terminaux utilisés. A cette fin, un "mode de dessin" (draw_mode) est associé à chaque protocole de gestion de terminal.

Quelques configurations sont déjà définies : vt100, tty, …. Il vous appartient d'ajouter à dessin.m2 celles qui correspondent aux terminaux que vous utilisez.

Pour définir un nouveau mode de dessin, vous devez:

Lui donner un nom interne, qui est un identificateur (tty, vt100, etc...) un nom externe, qui est une chaîne de caractères ("TTY", "VT100", etc...) et associer ces deux noms en ajoutant une assertion:

termi(nom_externe,nom_interne) ->;

Notez que l'utilisateur final n'est censé connaître que le nom externe.

Ajouter deux nouvelles définitions des règles en_graphique et

hors_graphique qui commandent le passage du terminal du mode caractères au mode semi-graphique et réciproquement.

A!ociation

Prolog

HERITAGE

©PrologIA

A!ociation

Prolog

HERITAGE

Les entrées / sorties

R 5 - 15

Ajouter une nouvelle règle config définissant les chaînes de caractères qui, en mode graphique, provoquent l'affichage des graphismes indiqués.

Remarque: Dans tous les cas, le mode "TTY" permet d'obtenir des dessins approximatifs sans utiliser aucune possibilité graphique du terminal. Ceci peut s'avérer utile, par exemple, pour imprimer des dessins d'arbres sur une imprimante classique.

5.4. Déclaration d'opérateurs

Les opérateurs permettent une notation sans parenthèses des termes fonctionnels à un ou deux arguments. Le symbole fonctionnel est remplacé par un opérateur placé en position:

- infixé pour les termes fonctionnels à deux arguments.

- préfixé ou postfixé pour les termes fonctionnels à un argument.

Un opérateur est défini par un symbole, une précédence, et des règles de parenthésage. Pour lever l'ambiguïté des expressions contenant plusieurs opérateurs, on parenthèse d'abord les opérateurs de plus faible précédence. Lorsque des opérateurs ont même précédence, on utilise les règles de parenthésage. La syntaxe des expressions avec opérateurs et les opérateurs prédéfinis sont donnés section

1.9.2 de ce manuel.

Exemple:

/ opérateur binaire de précédence 400, parenthésage à gauche d'abord

- opérateur binaire de précédence 500, parenthésage à gauche d'abord expression: expression non ambiguë: ((3 - 2) - ((1 / 4) / 3))) arbre Prolog:

3 - 2 - 1 / 4 / 3 sub(sub(3,2),div(div(1,4),3))

Il faut remarquer que si la notation avec opérateur est plus légère, son abus peut mener à une réelle difficulté de compréhension des arbres effectivement représentés par des expressions contenant des opérateurs peu usités.

op(n,i1,s) op(n,i1,s,i2)

Déclarent l'opérateur s avec la précédence n (0 <= n <= 1200) et le type de parenthésage i1. s est un identificateur, ou une chaîne représentant un symbole graphique. Dans la forme à 3 arguments, s peut être une liste, la déclaration s'applique alors à chaque élément de la liste. La forme à 3 arguments est aussi une directive de compilation, c'est à dire que la déclaration d'un opérateur peut aussi se faire au milieu d'un source que l'on compile. Le symbole fonctionnel représenté par s est i2 si celui-ci est défini, sinon le symbole s quoté.

L'associativité i1 est précisée par un identificateur combinant deux ou trois des lettres f,x,y avec les conventions suivantes:

représente l'opérateur.

représente une expression de précédence inférieure à f.

représente une expression de précédence inférieure ou égale à f.

©PrologIA

R 5 - 16

Manuel de Référence

Les combinaisons possibles sont:

fx Opérateur préfixé avec opérande de précédence inférieure.

fy Opérateur préfixé avec opérande de précédence inférieure ou égale.

xf Opérateur postfixé avec opérande de précédence inférieure.

yf Opérateur postfixé avec opérande de précédence inférieure ou égale.