Un interprète LISP
(LISt Processor) évalue des expressions. Ces
expressions utilisent des parenthèses et une notation préfixe un peu
particulière : la parenthèse ouvrante est placée avant le nom
de la fonction et non après comme il est d'usage.
max(x,y) | (max x y) | pas de virgule mais des espaces comme séparateur |
x + y | (+ x y) | les opérateurs sont notés comme les fonctions |
x = z | (setq x z) | l'affectation est dénotée setq |
x = y > 0 ? z1 : z2 |
(setq x (if (> y 0) z1 z2)) |
et bien sûr la fonction if |
Cette notation permet d'exprimer n'importe quel programme.
if ( x > 0 ) { y = 2 * y ;} else { y = 1; printf("Tilt\n"); } |
(if (> x 0) (setq y (* 2 y)) (setq y 1) (message "Tilt")) |
|
while ( n > 0 ) { x = x + f(n) ; n--; } |
(while (> n 0) (setq x (+ x (f n))) (setq n (- n 1))) |
|
{ int s = 0; s = f(s,x1); s = f(s,x2) ; ... } |
(let ( (s 0) ) (setq s (f s x1)) (setq s (f s x2)) ... ) |
|
int fact( int n ) { return n == 0 ? 1 : n * f(n - 1); } |
(defun fact (n) "Calcule factorielle N" (if (= n 0) 1 (* n (fact (- n 1))))) |
Emacs contient un grand nombre de fonctions prédéfinies comme
if
, setq
, *
, defun
... ;
mais aussi des fonctions comme forward-char
, apropos
,
find-file
, ... Les fonctions de ce deuxième groupe ont la
particularité d'être interactives. Cela signifie qu'elle définissent
alors des commandes qu'il est possible de lier à des clés.
Ainsi la clé C-f
est en général
liée à la commande forward-char
, qui provoque
l'évaluation de l'expression LISP
(forward-char)
qui avance le
curseur d'une position à droite dans le buffer courant.
Par contre if
ou setq
ne sont pas interactives, ce ne
sont pas des commandes.
Il est possible de transmettre un paramètre à une fonction déclenchée par une
commande. Par exemple la commande find-file
, en général liée à la
clé C-x C-f
, provoque
l'évaluation de
(find-file "fichier")
où fichier est une chaîne de caractères
acquise dans le mini-buffer.
De même, si on tape C-u 12 C-f cela provoque
l'évaluation de
(forward-char 12)
qui avance le curseur
de 12 positions à droite dans le buffer courant.
Pour accéder à l'interprète d'Emacs deux commandes sont particulièrement utiles :
execute-extended-command
: cette commande, en général liée à
la clé
M-x
, provoque l'exécution d'une commande dont le nom est
acquis dans le mini-buffer.
eval-expression
: cette commande, en général liée à la clé
M-:
,
permet d'obtenir l'évaluation d'une expression LISP acquise dans le
mini-buffer. Le résultat de l'évaluation est affiché aussi dans le mini-buffer.
Il y a donc 3 manières d'obtenir que le curseur se déplace d'une
position à droite dans le buffer courant :
C-f ou
M-x forward-char RET ou
M-: (forward-char) RET .
Pour déplacer le curseur de 12 positions à droite on a les 3 solutions
suivantes :
C-u 12 C-f ou
C-u 12 M-x forward-char RET ou
M-: (forward-char 12) RET .
Il y a aussi 3 manières de charger le fichier toto.c dans un
buffer :
C-x C-f toto.c ou
M-x find-file RET toto.c RET ou
M-: (find-file "toto.c") RET .
D'autres commandes utiles sont :
eval-last-sexp
: en général liée à la clé C-x
C-e
, provoque l'évaluation de l'expression LISP immédiatement
avant le curseur dans le buffer courant. Le résultat est affiché dans le
mini-buffer.
eval-region
: provoque l'interprétation de toute la région
courante dans le buffer courant.load-file
: après l'acquisition dans le mini-buffer d'un nom
de fichier, tout le fichier est interprété.