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"}

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.

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 !";

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.

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 :

valeur de t catégorie lexicale valeur de u

1 identifier l'identificateur

2 separator1 _{la chaîne correspondante}

3 variable la chaîne correspondante

4 constant la constante

5 graphic_symbol 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}

> 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}