LECCION 6. ENTRADA/SALIDA Y ERRORES. En esta lección se exponen y aplican las construcciones Lisp que permiten la comunicación con el mundo exterior (E/S), así como algunas de las que permiten la señalización y el manejo de errores de ejecución. Al finalizar la lección, el alumno debe ser capaz de -escribir funciones que se comuniquen con el usuario a través del teclado y la pantalla (ej. 1, 2 y 3). -manejar datos de tipo carácter y cadena (ej. 2) -escribir funciones que se comuniquen con ficheros del sistema (ej. 4 y 5). -modificar el lector del sistema Lisp mediante el uso de caracteres macro (ej. 6 y 7). -escribir funciones que se comporten de forma robusta ante los errores de ejecución (ej. 8, 9 y 10) "Hello world!" (Programador C anónimo).

Inteligencia Artificial e I.C.. 2002/2003

6.1

Dpto. Leng. Ciencias Comp.

Inteligencia Artificial e I.C.. 2002/2003

6.2

Dpto. Leng. Ciencias Comp.

R.6.1. E/S de supervivencia. a) Escribir una función sin argumentos que devuelva la suma de dos números leídos del teclado. b) Escribir una función sin argumentos que devuelva NIL y como efecto lateral escriba en la pantalla: i) dos mensajes solicitando cada uno que se teclee un número y ii) el resultado de su suma. c) Escribir una función EVALQUOTE que modifique la interacción con LISP de la siguiente forma: - el aviso (“prompt”) del intérprete debe ser EVALQUOTE> -si el usuario teclea >EVAL, se vuelve al modo habitual -en otro caso, el usuario debe teclear un nombre de función (en sentido estricto, es decir, no valen formas especiales ni macros) y la lista de sus argumentos sin comillas. Por ejemplo > EVALQUOTE EVALQUOTE> CONS(A (B)) (A B) EVALQUOTE> EVAL > ************************** SOLUCION: a) READ es una función que tiene el siguiente significado funcional predefinido: (READ) -ningún argumento (de momento). -el valor devuelto se toma de la corriente de entrada por defecto. Por ahora, podemos suponer que se toma del teclado. Según esto, la solucion será (DEFUN KK1 () (+ (READ) (READ))) b) PRIN1 es una función que tiene el siguiente significado funcional predefinido: (PRIN1 expresión) -un único argumento. -el valor devuelto es del argumento. -como efecto lateral, el valor es enviado a la corriente de salida por defecto. Por ahora podemos suponer que el valor se escribe en la pantalla. (TERPRI) escribe una línea en blanco. (PRINT expresión) es como PRIN1, con la siguiente diferencia: -como efecto lateral, el valor es enviado a la corriente de salida por defecto, precedido por un salto de línea y seguido por un espacio. Por el ap. anterior, sabemos que (+ (READ) (READ)) calcula la suma de dos números leídos del teclado. Para escribirla tendremos que hacer (PRINT (+ (READ) (READ))) Sin embargo, de esta forma no consegimos escribir los mensajes que piden los datos. Para ello hay que añadir para cada READ un PRINT que lo abrace: (PRINT (+ (CADR (LIST (PRINT '(DAME UN NUMERO)) (READ))) (CADR (LIST (PRINT '(DAME UN NUMERO)) (READ))))) y finalmente (DEFUN KK2 () (PRINT (+ (CADR (LIST (PRINT '(DAME UN NUMERO)) (READ))) (CADR (LIST (PRINT '(DAME UN NUMERO)) (READ))))) NIL) NOTA: El intérprete escribe siempre en la pantalla el valor de la expresión que se le teclea. Por tanto, si la anterior expresión se teclea directamente al intérprete, el resultado aparecerá dos veces en la pantalla: una, por el funcionamiento normal del intérprete; otra, como efecto lateral de su evaluación.

Inteligencia Artificial e I.C.. 2002/2003

6.3

Dpto. Leng. Ciencias Comp.

NOTA: [Ch] afirman (p. 29): "LISP tiene varias funciones, como PRINT o MAPC, que existen solamente por sus efectos laterales. No es en absoluto una buena idea depender de sus valores". Sin embargo, el valor de PRINT está perfectamente especificado en la definición de Common Lisp, y el empleo de este valor no debe ocasionar problemas.

c) Una definición recursiva por la cola: (DEFUN EVALQUOTE () (PRINT 'EVALQUOTE>) (LET ((F (READ))) (COND ((EQ F '>EVAL) NIL) ( T (PRINT (APPLY F (READ))) (EVALQUOTE)))))

;escribir nueva línea y el aviso ;leer la funcion f ;si es >EVAL, acabar, si no ;leer lista, aplicar f, ;escribir nueva línea y f(lista) ;y seguir en evalquote

NOTA. El funcionamiento normal del intérprete puede describirse como un bucle READ-EVALPRINT: se lee una expresión con READ, se evalúa con EVAL y se escribe el resultado con PRINT. El ejercicio anterior muestra cuán fácilmente se puede simular o modificar este bucle.

Inteligencia Artificial e I.C.. 2002/2003

6.4

Dpto. Leng. Ciencias Comp.

R.6.2. Caracteres y cadenas. a) Evaluar las siguientes expresiones: #\A #\Space (CHARACTER 41) (EQ #\A #\a) (EQ #\A #\A) (EQL #\A #\A) (CHAR= #\A #\A) (CHAR= #\SPACE (CHARACTER 32)) (CHAR-EQUAL #\A #\a) b) Evaluar las siguientes expresiones: "Hoy es jueves" (EQUAL #\A "A") (EQL "AB" "AB") (EQUAL "AB" "AB") (EQUAL (STRING 'A) (STRING #\A)) (EQ (INTERN "ABC") 'ABC) (ELT (STRING 'PEPE) 1) (LENGTH (STRING 'PEPE)) (CONCATENATE 'STRING "ABC" "XYZ") (EQUAL "PEPE" "PEPE") (STRING= "PEPE" "pepe") (STRING-EQUAL "PEPE" "pepe") c) Indicar qué se imprime al introducir sucesivamente las siguientes expresiones: (PRINC #\k) (PRINC "pEPE") (PRINC "C:\\PEPE") (PRINC "PEPE\"") (PRIN1 "PEPE") (DEFUN MI-PRINC (S) (TERPRI) (PRINC S)) (MI-PRINC "PEPE") ************************** SOLUCION: a) Además de números, símbolos, funciones y listas, CommonLisp tiene predefinidos otros tipos de datos: por ejemplo, los caracteres (character). Los caracteres son átomos y se evalúan a sí mismos. Para indicar que algo es un carácter, el usuario (y PRINT) lo escribe precedido de #\. La función (CHARACTER n) devuelve el carácter designado por n (la forma concreta de designación depende de la implementación; por ejemplo, n puede ser el código ASCII del carácter). Por tanto #\A =>#\A #\Space =>#\Space (CHARACTER 41) => #\) No es obligado que distintas apariciones de un mismo carácter sean EQ, pero sí que sean EQL. Las funciones especializadas CHAR= y CHAR-EQUAL sirven para comparar únicamente caracteres. CHAREQUAL no distingue entre mayúsculas y minúsculas. Por supuesto, un símbolo cuyo nombre conste de un solo carácter no es lo mismo que un carácter. Por tanto (EQ #\A #\a) => NIL (EQ #\A #\A) => ...depende de la implementación... (EQL #\A #\A) => T (CHAR= #\A #\A) => T (CHAR= #\SPACE (CHARACTER 32)) => T (CHAR-EQUAL #\A #\a) => T b) El tipo cadena (string) está también predefinido. Las cadenas son átomos y se evalúan a sí mismas. Una cadena de un solo carácter no es lo mismo que un carácter. Para indicar que algo es una cadena, el usuario (y PRINT) lo escribe entre comillas dobles. La función STRING transforma caracteres y símbolos en cadenas. La función INTERN transforma cadenas en símbolos. Por tanto

Inteligencia Artificial e I.C.. 2002/2003

6.5

Dpto. Leng. Ciencias Comp.

"Hoy es jueves" => "Hoy es jueves" (EQUAL #\A "A") => NIL (EQL "AB" "AB") => NIL (EQUAL "AB" "AB") => T (EQUAL (STRING 'A) (STRING #\A)) => T (EQ (INTERN "ABC") 'ABC) => T La función (ELT cadena n) extrae el n-ésimo carácter de cadena (el primero es el 0-ésimo). (ELT (STRING 'PEPE) 1) => #\E La función LENGTH da la longitud de una cadena: (LENGTH (STRING 'PEPE)) => 4 Nótese que la misma función LENGTH sirve para listas y de cadenas. De la misma forma, ELT puede emplearse también para extraer el enésimo elemento de una lista. La razón es que estas funciones, y otras muchas, están definidas para el tipo sucesión (sequence), que comprende listas, cadenas y vectores. La función CONCATENATE, por ejemplo, sirve para APPENDar tato listas como cadenas. Su primer argumento es un símbolo que indica el tipo del resultado. Por tanto (CONCATENATE 'STRING "ABC" "XYZ") => "ABCXYZ" y también tendríamos (CONCATENATE 'LIST '(A B C) '(D C)) => (A B C D C) (CONCATENATE 'LIST "ABC" "XYZ") => (#\A #\B #\C #\X #\Y #\Z) No es obligado que distintas apariciones de una misma cadena sean EQL, pero sí que sean EQUAL. Las funciones especializadas STRING= y STRING-EQUAL sirven para comparar únicamente cadenas, análogamente a CHAR= y CHAR-EQUAL. Por tanto (EQUAL "PEPE" "PEPE") => T (STRING= "PEPE" "pepe") => NIL (STRING-EQUAL "PEPE" "pepe") => T c) La función PRINC es análoga a PRIN1, con la diferencia de que escribe sin delimitadores cadenas y caracteres: > (PRINC #\k)k #\k > (PRINC "pEPE")pEPE "pEPE" > (PRIN1 "PEPE")"PEPE" "PEPE" El carácter \ sirve como carácter de escape dentro de una cadena, para indicar que el siguiente carácter debe tomarse literalmente. Su empleo es necesario si se desea que " o \ formen parte de la cadena: > (PRINC "C:\\PEPE")C:\PEPE "C:\\PEPE" > (PRINC "PEPE\"")PEPE" "PEPE\"" > (DEFUN MI-PRINC (S) (TERPRI) (PRINC S)) MI-PRINC > (MI-PRINC "PEPE") PEPE "PEPE" . NOTA: La diferencia entre PRIN1 y PRINC puede resumirse como sigue: PRIN1 escribe su argumento respetando las convenciones exigidas por READ; PRINC escribe su argumento de forma que un ser humano lo lea cómodamente.

Inteligencia Artificial e I.C.. 2002/2003

6.6

Dpto. Leng. Ciencias Comp.

R.6.3. FORMAT Escribir una función KK1 que lleve a cabo la siguiente tarea: solicitar al usuario que introduzca una expresión numérica y escribir en distintos renglones los valores de su cubo y su cuadrado, con los correspondientes mensajes, en formato decimal y con dos decimales. En caso de introducir un dato no numérico se dará al usuario un mensaje adecuado y se le solicitará de nuevo un valor. La función devuelve siempre T. Por ejemplo: Dime una expresión: PEPE PEPE no es un número, lo siento. Dime una expresión: 2E-1 El cuadrado es 0.04 y el cubo es 0.00. Adiós. T ************************** SOLUCION: Para conseguir salidas formateadas se emplea la función FORMAT: (FORMAT destino cadena-control expresión*) donde destino es la corriente de salida. Si es T, se toma la corriente de salida por defecto (normalmente, la pantalla); si es NIL, se crea una cadena que contiene la salida. expresión* es una sucesión de expresiones, que se evalúan secuencialmente para obtener valor1, ..., valorn. cadena-control es una cadena. Si destino es NIL, FORMAT devuelve la cadena descrita más adelante. En otro caso, FORMAT se evalúa a NIL y como efecto lateral escribe en destino los valores valor1, ..., valorn, formateados de acuerdo a las instrucciones de la cadena de control. Concretamente: -La cadena de control se escribe literalmente en la corriente de salida, a excepción de los caracteres precedidos por ~, que se denominan directivas de formateo. -La directiva ~S hace que en su lugar se escriba (como con PRIN1) uno de los valores valor1, ..., valorn. La directiva ~A hace que en su lugar se escriba (como con PRINC) uno de los valores valor1, ..., valorn. El valor es determinado secuencialmente (el primer valor con el primer ~S o ~A, ...). Si hay más directivas que valores, se produce un error. Si hay más valores que directivas, no se produce por ello error: simplemente, los últimos valores no se escriben. -La directiva ~% escribe un salto de línea. -La directiva ~ ignora la y los blancos que la sigan. Por ejemplo >(FORMAT T "~%Hoy es ~S de ~S de ~S." 12 "enero" 1492) Hoy es 12 de "enero" de 1492. NIL >(FORMAT T "~%Hoy es ~S de ~A de ~S." 12 "enero" 1492) Hoy es 12 de enero de 1492. NIL >(FORMAT NIL "~%Hoy es ~S de ~A de ~S." 12 "enero" 1492) " Hoy es 12 de enero de 1492." -La directiva ~n,mF escribe un número en formato decimal, como mínimo con un total de n caracteres, empleando m decimales. Por ejemplo >(FORMAT T "~% Un número:~10,3F.~% El mismo número:~5,2F.~% Y otra vez ~ el mismo número:~2,0F." 123.1 123.1 123.1) Un número: 123.100. El mismo número:123.10. Y otra vez el mismo número:123.. NIL Según esto (DEFUN MENSAJE (CADENA)

Inteligencia Artificial e I.C.. 2002/2003

6.7

Dpto. Leng. Ciencias Comp.

(PRINC CADENA) (READ)) (DEFUN KK1 () (LET ((S (MENSAJE "Dime una expresion: "))) (COND((NUMBERP S) (FORMAT T "~%El cuadrado es ~6,2F y el cubo es ~6,2F~ .~%Adios." (* S S) (* S S S)) T) (T (FORMAT T "~%~S no es un numero, lo siento." S) (KK1))))) NOTA: (FORMAT T ...) devuelve NIL. Para respetar la definición especificada de KK1, es necesario por tanto introducir explícitamente T como valor del COND. Compárese con PRIN1 o PRINT, que devuelven el valor de su argumento. NOTA. La definición completa de FORMAT ocupa 29 páginas de CLtL2 (581-609), y otras tantas del estándar ANSI. El alumno interesado puede consultar allí todas las posibilidades de formateo (numérico, alfanumérico, condicional, mediante funciones, ...) que FORMAT proporciona.

Inteligencia Artificial e I.C.. 2002/2003

6.8

Dpto. Leng. Ciencias Comp.

R.6.4. Secuenciación. Evaluar las siguientes expresiones: (PROGN (+ 1 2 3) (CAR '(A B))) (PROG1 (+ 1 2 3) (CAR '(A B))) (LOOP (+ 1 2 3) (CAR '(A B))) (LOOP (PRINT 'DIGA?) (WHEN (EQ (READ) 'FIN) (RETURN)) (PRINT 'OIDO)) (LOOP (PRINT 'DIGA?) (WHEN (EQ (READ) 'FIN) (RETURN T)) (PRINT 'OIDO)) (BLOCK PEPE (+ 1 2 3) (CAR '(A B))) (BLOCK PEPE (PRINT 'DIGA?) (WHEN (EQ (READ) 'FIN) (RETURN-FROM PEPE)) ESTO ES BASURA) (BLOCK PEPE (BLOCK JUAN (PRINT 'DIGA?) (IF (EQ (READ) 'PEPE) (RETURN-FROM PEPE 'ADIOS) (RETURN-FROM JUAN 'JA))) ESTO ES BASURA) ************************** SOLUCION: La secuenciación es la forma básica en que fluye la ejecución de los programas imperativos. Sin embargo, en los programas funcionales la secuenciación tiene una importancia más reducida. De hecho, hasta ahora no la hemos mencionado explícitamente. Sin embargo, al programar mediante "efectos laterales" (entrada/salida, asignación), es inevitable el uso de la secuenciación. Los operadores más sencillos son PROGN y PROG1, que evalúan secuencialmente las expresiones de su cuerpo y devuelven el último valor o el primero, respectivamente: (PROGN (+ 1 2 3) (CAR '(A B))) => A (PROG1 (+ 1 2 3) (CAR '(A B))) => 6 NOTA. Muchas de las construcciones ya estudiadas (DEFUN, COND, ...) ejecutan siempre secuencialmente las expresiones de su cuerpo. Pero nótese que en IF y en las inicializaciones y actualizaciones de LET y DO es necesario para ello un PROGN explícito. El operador LOOP evalúa secuencialmente las expresiones de su cuerpo, una y otra vez; en principio, no devuelve ningún valor: (LOOP (+ 1 2 3) (CAR '(A B))) => ...computación infinita... Sin embargo, si dentro del cuerpo se evalúa una forma (RETURN), finaliza el cálculo y LOOP devuelve NIL. El ámbito desde el cual se puede RETURNar se determina léxicamente. (LOOP (PRINT 'DIGA?) (WHEN (EQ (READ) 'FIN) (RETURN)) (PRINT 'OIDO)) => DIGA? HOLA OIDO DIGA? FIN

Inteligencia Artificial e I.C.. 2002/2003

6.9

Dpto. Leng. Ciencias Comp.

NIL Si se evalúa (RETURN e), se devuelve el valor de e: (LOOP (PRINT 'DIGA?) (WHEN (EQ (READ) 'FIN) (RETURN T)) (PRINT 'OIDO)) => DIGA? HOLA OIDO DIGA? FIN T El operador más general que establece la posibilidad de RETURNar es BLOCK, que se emplea en formas como (BLOCK nombre expresión*) nombre es un símbolo que no se evalúa. Las restantes expresiones se evalúan secuencialmente y BLOCK devuelve el valor de la última. Pero si alguna de ellas es de una forma (RETURN-FROM nombre resultado) el valor de resultado pasa a ser el de la forma BLOCK y las restantes expresiones quedan sin evaluar. (BLOCK PEPE (+ 1 2 3) (CAR '(A B))) => A (BLOCK PEPE (PRINT 'DIGA?) (WHEN (EQ (READ) 'FIN) (RETURN-FROM PEPE)) ESTO ES BASURA) => DIGA? FIN NIL Los bloques pueden anidarse. En los anidamientos se siguen las reglas de ámbito léxico. (BLOCK PEPE (BLOCK JUAN (PRINT 'DIGA?) (IF (EQ (READ) 'PEPE) (RETURN-FROM PEPE 'ADIOS) (RETURN-FROM JUAN 'JA))) ESTO ES BASURA) => DIGA? PEPE ADIOS (BLOCK PEPE (BLOCK JUAN (PRINT 'DIGA?) (IF (EQ (READ) 'PEPE) (RETURN-FROM PEPE 'ADIOS) (RETURN-FROM JUAN 'JA))) ESTO ES BASURA) => DIGA? NO-PEPE Error: ESTO sin ligar. NOTA. DEFUN establece implícitamente un bloque con el nombre de la función. LOOP, DO y sus variantes establecen implícitamente un bloque con el nombre NIL. En lugar de RETURN-FROM NIL se puede escribir simplemente RETURN

Inteligencia Artificial e I.C.. 2002/2003

6.10

Dpto. Leng. Ciencias Comp.

R.6.5. Manejo elemental de archivos. Sea un sistema bajo MS-DOS. En un fichero llamado KK.DAT, situado en el directorio C:\DBVARIOS, se almacenan las lecturas de un sensor, tomadas cada hora. El primer dato del archivo es la fecha (formato dd-mm-aa), el segundo la hora de la primera lectura y el tercero los minutos de la primera lectura. a) Evaluar las siguientes expesiones, indicando los efectos laterales: (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) 1 2 3 F1) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (READ F1)(READ F1)) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\QQ.DAT" :DIRECTION :OUTPUT) (PRIN1 'PEPE F1) (PRIN1 2 F1)) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LOOP (READ F1))) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LOOP (READ F1 NIL))) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LOOP (UNLESS (READ F1 NIL) (RETURN NIL)))) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) EE) b) Escribir una función LISP LEE1 que lea el archivo y escriba en pantalla una tabla como la siguiente: Datos del día 17-2-96 HORA LECTURA ==== ======= 00:20 123.14 01:20 0.00 02:20 23.01 ... c) Escribir una función LISP LEE2 que lea el archivo y escriba una tabla como la anterior en un fichero KK.TXT. ************************** SOLUCION: En CommonLisp, una fuente o sumidero de datos se denomina corriente (stream). Una corriente es un objeto Lisp, y por tanto puede ser el valor de la ligadura de un símbolo. Por otra parte, una corriente debe corresponder a un objeto del mundo exterior, de donde se toman los datos o a donde se envían. Las funciones de E/S ya vistas (READ, PRINT, ...) pueden operar sobre cualquier corriente. Para ello la corriente se introduce como argumento adicional: (READ expresión-c) (PRIN1 expresión expresión-c) (PRINC expresión expresión-c) (PRINT expresión expresión-c) En cuanto a FORMAT, ya hemos dicho que su primer argumento puede ser, además de T o NIL, cualquier corriente: (FORMAT expresión-c cadena-control expresión*) En todos estos casos, expresión-c debe evaluarse a una corriente. Una corriente puede ser binaria o de caracteres; puede usarse para sólo lectura, sólo escritura o ambas operaciones a la vez; y puede estar abierta (accesible como fuente o sumidero de datos) o cerrada (inaccesibe). La manera más sencilla y recomendable de crear corrientes para comunicarse con ficheros, y además ligarlas a símbolos, es emplear la forma WITH-OPEN-FILE: (WITH-OPEN-FILE (símbolo expr-fichero opción*)expr*) donde expr-fichero es una expresión que debe evaluarse a un nombre de fichero valido según las convenciones del sistema operativo subyacente. La evaluación de WITH-OPEN-FILE crea primeramente una corriente ligada a este fichero, que queda ligada a símbolo en todo el ámbito de la evaluación. Esta corriente se abre de la forma señalada por opción*. De esta forma se evalúan las expresiones siguientes. Finalmente se cierra la corriente. El valor devuelto por WITH-OPEN-FILE es el de la última expresión. El archivo siempre queda cerrado, aun cuando la evaluación de WITH-OPENFILE haya terminado prematuramente.

Inteligencia Artificial e I.C.. 2002/2003

6.11

Dpto. Leng. Ciencias Comp.

La corriente se describe mediante los siguientes parámetros clave: :DIRECTION. Puede ser :INPUT, :OUTPUT, :IO. Por defecto es :INPUT :ELEMENT-TYPE. Puede ser CHARACTER, BIT, SIGNED-BYTE, UNSIGNED-BYTE... Por defecto es CHARACTER (en realidad, un subtipo de CHARACTER). Por tanto a) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) 1 2 3 F1) => # (Se ha creado una corriente para lectura de caracteres asociada al archivo C:\DBVARIOS\KK.DAT, se ha abierto y se ha cerrado). (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (READ F1)(READ F1)) => 0 (Se ha creado una corriente para lectura de caracteres asociada al archivo C:\DBVARIOS\KK.DAT y se ha abierto. El primer READ ha leído el primer dato del archivo -la fecha- y el segundo, el segundo dato -la hora de la primera lectura, que es 0- Finalmente, el archivo se ha cerrado). (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\QQ.DAT" :DIRECTION :OUTPUT) (PRIN1 'PEPE F1) (PRIN1 2 F1)) =>2 (Se ha creado una corriente para escritura de caracteres asociada al archivo C:\DBVARIOS\QQ.DAT y se ha abierto. El primer PRIN1 ha escrito PEPE y el segundo, 2. Finalmente, el archivo se ha cerrado. Nótese que PRIN1 no añade blancos ni saltos de línea, por lo que el contenido del archivo es ahora PEPE2). Los siguiente ejemplos hacen uso del operador LOOP. En el caso más sencillo, (LOOP cuerpo) evalúa una y otra vez las expresiones que forman cuerpo. Por tanto (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LOOP (READ F1))) => Error: intento de leer más allá del fin del fichero. (Se ha creado una corriente para lectura de caracteres asociada al archivo C:\DBVARIOS\KK.DAT y se ha abierto. Se han ejecutado los READ hasta llegar al fin del fichero, donde se ha producido un error). El error anterior se puede evitar, añadiendo más argumentos a READ: (READ expresión-c error-eof-p [valor-eof]) Si error-eof-p es falso, no se produce el error de fin de fichero, sino que READ devuelve valoreof (valor por defecto, NIL) cuando intenta ir más allá. Por tanto: (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LOOP (READ F1 NIL))) ... (bucle infinito: no se produce error y READ se evalúa a NIL una vez alcanzado el fin del fichero) (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LOOP (UNLESS (READ F1 NIL) (RETURN NIL)))) => NIL (DEFUN F (N) (+ N EE)) => F (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (F 1)) => Error: EE sin ligar. Tanto en este caso como en alguno de los anteriores, se ha producido un error de ejecución mientras se estaba leyendo o escribiendo un fichero. En general, esto puede tener consecuencias fatales para la información contenida en él; sin embargo, la forma WITH-OPEN-FILE se asegura de que el fichero no se perjudique. Sea cual sea el error que haga abortar la evaluación de una forma WITH-OPENFILE, el sistema garantiza que el fichero queda cerrado. Aún más: el fichero queda cerrado independientemente de que el error se haya producido en un entorno –como el del último ejemplodonde léxicamente no estaba vigente la ligadura que lo señala.

Inteligencia Artificial e I.C.. 2002/2003

6.12

Dpto. Leng. Ciencias Comp.

NOTA. Este efecto puede programarse explícitamente con una forma UNWIND-PROTECT. b) Hay que abrir para lectura de caracteres el fichero C:\DBVARIOS\KK.DAT. Primero se lee la fecha, hora y minutos iniciales. A continuación se leen los datos del sensor. Como no sabemos cuántos hay, leemos con (READ NIL 'EOF) para evitar el error de fin de fichero: (DEFUN LEE1 () (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (LET ((FECHA (READ F1)) (HORA (READ F1)) (M (READ F1))) (FORMAT T "~%Datos del día ~A" FECHA) (FORMAT T "~%HORA LECTURA") (FORMAT T "~%==== =======") (DO ((L (READ F1 NIL 'EOF)(READ F1 NIL 'EOF)) (H HORA (1+ H))) ((EQ L 'EOF) NIL) (FORMAT T "~%~2,D:~2,D ~6,2F" H M L))))) c) Al programa anterior hay que añadirle la creación de una corriente de salida. Nótese que pueden crearse cuantas corrientes sea necesario, así como tenerlas simultáneamente abiertas. Nótese también que FORMAT escribe en el fichero exactamente lo que escribiría en la pantalla si el primer argumento fuera T. (DEFUN LEE2 () (WITH-OPEN-FILE (F1 "C:\\DBVARIOS\\KK.DAT" :DIRECTION :INPUT) (WITH-OPEN-FILE (FS "C:\\DBVARIOS\\KK.TXT" :DIRECTION :OUTPUT) (LET* ((FECHA (READ F1)) (HORA (READ F1)) (M (READ F1))) (FORMAT FS "~%Datos del día ~A" FECHA) (FORMAT FS "~%HORA LECTURA") (FORMAT FS "~%==== =======") (DO ((L (READ F1 NIL 'EOF)(READ F1 NIL 'EOF)) (H HORA (1+ H))) ((EQ L 'EOF) NIL) (FORMAT FS "~%~2,D:~2,D ~6,2F" H M L))))))

Inteligencia Artificial e I.C.. 2002/2003

6.13

Dpto. Leng. Ciencias Comp.

R.6.6. Lectura de líneas y caracteres. a) Escribir una función CODIFICAR, que tenga como argumentos dos nombres de fichero ENTRADA y SALIDA y produzca como efecto lateral la escritura en SALIDA de los caracteres contenidos en ENTRADA codificados según la siguiente regla: si el código ASCII de c es n, su codificación es el carácter de código (n +23) mod 128. b) Escribir en LISP una función TFD que corresponda a un traductor finito determinista para convertir una cadena de caracteres en una lista de tokens. Se suponen los tokens "variable" y "constante" y las reglas de Prolog para definir ambos. Para separar los diversos identificadores en la entrada se admiten blancos, comas, tabuladores y saltos de línea. La función debe devolver para cada par (estado, carácter de entrada) el nuevo estado y el token emitido correspondiente (NIL si no se emite ninguno). El fin de la cadena de entrada se supone señalado por el carácter "$". c) Escribir en LISP una función TRADUCIR que tenga como argumentos un TFD y una cadena de caracteres, y devuelva la traduccion de la cadena hasta donde haya sido posible hacerla. Además, como valor secundario, se devolverá T si la traducción se ha podido efectuar por completo, NIL si ha acabado en fracaso. d) Escribir en LISP una función TRADUCIR-FICHERO-TEXTO que tenga como argumentos el cierre léxico de un TFD y dos nombres de fichero ENTRADA y SALIDA. La función escribirá como efecto lateral la traduccion de ENTRADA en SALIDA hasta donde haya sido posible hacerla. El valor de la función será T si la traducción se ha podido efectuar por completo, NIL si ha acabado en fracaso. ************************** SOLUCION: Hemos dicho que READ lee una a una las expresiones LISP. Pero en realidad no sólo lee, sino que lleva a cabo un análisis lexicográfico y sintáctico de lo leído, para determinar, por ejemplo, dónde acaba cada expresión. Existen otras funciones de lectura más elementales, como por ejemplo READCHAR y READ-LINE, que sí se limitan a leer de una corriente. (READ-CHAR expresión-c error-eof-p [valor-eof]) lee un carácter. La función devuelve precisamente ese carácter. (READ-LINE expresión-c error-eof-p [valor-eof]) lee una línea completa, es decir, lee todos los caracteres hasta encontrar un salto de línea. La función devuelve la cadena formada por todos los caracteres de la línea (salvo el de salto). Es por ello muy útil para leer del teclado. READ-LINE devuelve también un segundo valor: "verdadero", si la línea acaba con el carácter de fin de fichero, "falso" en otro caso. Por tanto a) La función que realiza la codificación de un carácter es (LAMBDA (C) (CHARACTER (MOD (+ (CHAR-CODE C) 23) 128))) Leeremos de ENTRADA carácter a carácter, realizaremos la transformación y escribiremos en SALIDA carácter a carácter: (DEFUN CODIFICAR (&KEY ENTRADA SALIDA) (FLET ((DESPLAZAR (C) (CHARACTER (MOD (+ (CHAR-CODE C) 23) 128)))) (WITH-OPEN-FILE (CE ENTRADA :DIRECTION :INPUT) (WITH-OPEN-FILE (CS SALIDA :DIRECTION :OUTPUT) (LOOP (LET ((C (READ-CHAR CE NIL :EOF))) (WHEN (EQ C :EOF) (RETURN)) (PRINC (DESPLAZAR C) CS))))))) b) Un TFD queda definido por los siguientes elementos: -la tabla de transiciones. Cada transición es una tripla o cuádrupla de la forma (estado carácter-leído nuevo-estado [símbolo-emitido]). Cuando el TFD está en estado y lee carácter-leído pasa a nuevoestado y emite símbolo-emitido, caso de que exista. Si en la tabla no hay ninguna transición que empiece por esta combinación (estado carácter-leído ...), la traducción acaba en fracaso. Nunca hay más de una transición para una misma combinación (estado carácter-leído ...). -un conjunto de estados finales. Si al acabar de leer la cadena de entrada el TFD se halla en un estado final, la traducción ha acabado con éxito, caso contrario, en fracaso.

Inteligencia Artificial e I.C.. 2002/2003

6.14

Dpto. Leng. Ciencias Comp.

-un estado inicial, en el que se halla el TFD antes de leer ningún carácter. Representaremos los elementos anteriores por los siguientes datos LISP: - El segundo elemento de cada transición será un predicado, en lugar de un carácter. De esta forma reducimos considerablemente el tamaño de la tabla. La transición se considera aplicable a todos los caracteres que satisfacen el predicado. Según la gramática de Prolog, son variables las cadenas alfanuméricas que comienzan por una letra mayúscula o por "_". Son constantes las cadenas alfanuméricas que empiezan por una letra minúscula. (DEFUN SEPARADORP (C) (MEMBER C (LIST #\Newline #\Space #\Tab #\,))) (DEFUN TERMINADORP (C) (EQL C #\$)) (DEFUN TERMINAR (CAD) (CONCATENATE 'STRING CAD "$")) (DEFUN VACIAP (CADENA) (= 0 (LENGTH CADENA))) El TFD será (todos los estados finales) letra, dígito, _

E1 separador mayúscula, _

E0 minúscula letra, dígito, _

E2

Para considerar la terminación de la cadena, añadimos un estado T al que se llega al leer "$" en un estado final:

letra, dígito, _

E1 separador

$ mayúscula, _

E0

T minúscula

$ letra, dígito, _

E2

En Lisp

Inteligencia Artificial e I.C.. 2002/2003

6.15

Dpto. Leng. Ciencias Comp.

(DEFUN TFD1 (ESTADO C-LEIDO) (CASE ESTADO (E0 (COND ((TERMINADORP C-LEIDO) (VALUES T NIL)) ((FUNCALL #'UPPER-CASE-P C-LEIDO) (VALUES 'E1 NIL)) ((FUNCALL #'LOWER-CASE-P C-LEIDO) (VALUES 'E2 NIL)) ((FUNCALL #'(LAMBDA (C) (EQL C #\_)) C-LEIDO) (VALUES 'E1 NIL)) ((FUNCALL #'SEPARADORP C-LEIDO) (VALUES 'E0 NIL)))) (E1 (COND ((TERMINADORP C-LEIDO) (VALUES T 'VAR)) ((FUNCALL #'ALPHA-CHAR-P C-LEIDO) (VALUES 'E1 NIL)) ((FUNCALL #'(LAMBDA (C) (EQL C #\_)) C-LEIDO) (VALUES 'E1 NIL)) ((FUNCALL #'DIGIT-CHAR-P C-LEIDO) (VALUES 'E1 NIL)) ((FUNCALL #'SEPARADORP C-LEIDO) (VALUES 'E0 'VAR)))) (E2 (COND ((TERMINADORP C-LEIDO) (VALUES T 'CTE)) ((FUNCALL #'ALPHA-CHAR-P C-LEIDO) (VALUES 'E2 NIL)) ((FUNCALL #'(LAMBDA (C) (EQL C #\_)) C-LEIDO) (VALUES 'E2 NIL)) ((FUNCALL #'DIGIT-CHAR-P C-LEIDO) (VALUES 'E2 NIL)) ((FUNCALL #'SEPARADORP C-LEIDO) (VALUES 'E0 'CTE))))))

c) La función empleará por acumuladores, uno para la salida y otro para el estado en que se encuentra el traductor. Por otra parte, la entrada se completa en un primer paso con el carácter terminador: (DEFUN TRADUCIR (TFD ENTRADA &OPTIONAL SALIDA (ESTADO 'E0)) (LABELS ((TTRAD (TFD ENTRADA SALIDA ESTADO) (COND ((VACIAP ENTRADA) (VALUES (REVERSE SALIDA) ESTADO)) (T (MULTIPLE-VALUE-BIND (NUEVO-E NUEVA-SAL) (FUNCALL TFD ESTADO (ELT ENTRADA 0)) (COND ((NOT NUEVO-E) (VALUES (REVERSE SALIDA) NIL)) ((NOT NUEVA-SAL) (TTRAD TFD (SUBSEQ ENTRADA 1) SALIDA NUEVO-E)) (T (TTRAD TFD (SUBSEQ ENTRADA 1) (CONS NUEVA-SAL SALIDA) NUEVO-E)))))))) (LET ((ENTRADA (TERMINAR ENTRADA))) (TTRAD TFD ENTRADA SALIDA ESTADO))))

d) No hay más que llamar sucesivamente a TRADUCIR con las diversas líneas de ENTRADA, escribiendo al tiempo las traducciones en SALIDA. (DEFUN TRADUCIR-FICHERO-TEXTO (&KEY TRADUCTOR ENTRADA SALIDA) (WITH-OPEN-FILE (CORR1 ENTRADA :DIRECTION :INPUT) (WITH-OPEN-FILE (CORR2 SALIDA :DIRECTION :OUTPUT) (LOOP (LET ((LINEA (READ-LINE CORR1 NIL :EOF))) (WHEN (EQ LINEA :EOF) (RETURN T)) (MULTIPLE-VALUE-BIND (TRADUCC EXITO) (TRADUCIR TRADUCTOR LINEA) (WHEN (NOT EXITO) (RETURN)) (PRINT TRADUCC CORR2)))))))

Inteligencia Artificial e I.C.. 2002/2003

6.16

Dpto. Leng. Ciencias Comp.

R.6.7. Caracteres Macro. a) Evaluar en el orden dado las siguientes expresiones: (SET-MACRO-CHARACTER #\? #'(LAMBDA (CORRIENTE CARACTER) (LIST 'A 'B 'C)))) '(? (?)) (SET-MACRO-CHARACTER #\? #'(LAMBDA () (LIST 'A 'B 'C)))) '(? (?)) b) Queremos representar en un programa fórmulas de la lógica de primer orden. Para ello las variables lógicas serán listas de la forma (VAR X), cuyo CAR es el símbolo VAR y cuyo CADR es el nombre X de la variable. Modificar el significado de READ de manera que ?expresión se lea como (VAR expresión). ************************** SOLUCION: Un carácter macro es un carácter tal que READ lo trata de manera especial cuando lo encuentra, expandiéndolo en un conjunto de caracteres. Ya conocemos un carácter macro predefinido, el apóstrofo: cuando READ (bien en el ciclo normal del intérprete, bien en una llamada explícita) encuentra 'expresión, lo transforma inmediatamente en (QUOTE expresión). Es posible definir nuevos caracteres macro mediante la función SET-MACRO-CHARACTER: (SET-MACRO-CHARACTER carácter función) donde carácter es el caracter macro que se define y función es la función de expansión, que que determina lo que debe sustituir al carácter macro. Esta función debe tener dos argumentos: una corriente y un carácter. SET-MACRO-CHARACTER devuelve T y como efecto lateral modifica el significado de READ. A partir de este momento, cuando READ encuente el carácter macro lo sustituirá por el resultado de aplicar la función. Por tanto (SET-MACRO-CHARACTER #\? #'(LAMBDA (CORRIENTE CARACTER) (LIST 'A 'B 'C)))) => T '(? (?)) =>((A B C) ((A B C))) En este sencillo caso la función de expansión no emplea sus argumentos. Sin embargo, es necesario que figuren en su lista lambda: (SET-MACRO-CHARACTER #\? #'(LAMBDA () (LIST 'A 'B 'C)))) =>T '(? (?)) =>Error: número equivocado de argumentos. De hecho, lo más habitual será que la función de expansión contenga una llamada a (READ corriente ...). En este caso hay que añadir un cuarto argumento a READ con valor T (¿por qué? vd. nota). b) La función siguiente realiza la modificación especificada: (DEFUN HAZ-MI-READ () (SET-MACRO-CHARACTER #\? #'(LAMBDA (CORRIENTE CARACTER) (LIST 'VAR (READ CORRIENTE T NIL T)))))

Inteligencia Artificial e I.C.. 2002/2003

6.17

Dpto. Leng. Ciencias Comp.

> (HAZ-MI-READ) T > '?X (VAR X) > '??X (VAR (VAR X))

NOTA: Es bastante peligroso definir como caracteres macro caracteres alfabéticos o de uso común: a partir de ese momento, cualquier aparición de ellos se verá sustituida por su expansión. Por ejemplo, tras ejecutar la función HAZ-MI-READ de este ejercicio, no es posible emplear en el programa el signo de interrogación (salvo usando caracteres de escape). NOTA: Los caracteres macro se pueden agrupar en una tabla de lectura (readtable). Pueden existir varias tablas de lectura alternativas; según la que se cargue, READ leerá de una manera o de otra. NOTA: la definición completa de READ es (READ expresión-c error-eof-p valor-eof llamada-recursiva-p) donde todos los argumentos son opcionales. El cuarto, llamada-recursiva-p, (valor por defecto, NIL) indica si el READ se ejecuta en el nivel superior o bien proviene de la ejecución de otro READ. Puede ser importante distinguir entre ambos casos (vd. CLtL, pg. 568-569)

Inteligencia Artificial e I.C.. 2002/2003

6.18

Dpto. Leng. Ciencias Comp.

R.6.8. Caracteres macro de envío. a) Evaluar en el orden dado las siguientes expresiones: (MAKE-DISPATCH-MACRO-CHARACTER #\z) (SET-DISPATCH-MACRO-CHARACTER #\z #\z #'(LAMBDA (CORRIENTE SUBCAR NUM) (LIST 'A 'B 'C))) 'zz 'za 'ZZ b) Ahora queremos escribir el cuantificador universal como $E, abreviatura de la lista (EXISTE variable) y el universal como $U, abreviatura de la lista (PARA-TODO variable). Modificar adecuadamente el significado de READ. ************************** SOLUCION: a) Un carácter macro de envío (dispatching macro character) también es un carácter tal que READ lo trata de manera especial cuando lo encuentra, expandiéndolo en un conjunto de caracteres. Pero en este caso la expansión realizada depende, no sólo del carácter macro, sino también del siguiente carácter leído (subcaracter). Ya conocemos un carácter macro de envío predefinido, el sostenido: cuando READ (bien en el ciclo normal del intérprete, bien en una llamada explícita) encuentra #'expresión, lo transforma inmediatamente en (FUNCTION expresión). Es posible definir nuevos caracteres macro de envío mediante las funciones MAKE-DISPATCHMACRO-CHARACTER y SET-DISPATCH-MACRO-CHARACTER: (MAKE-DISPATCH-MACRO-CHARACTER carácter) Esta función devuelve T y hace que carácter sea un carácter macro de envío. Pero aún no establece su significado. Para ello es necesario emplear además (SET-DISPATCH-MACRO-CHARACTER carácter subcarácter función) donde carácter es el caracter macro de envío, subcarácter es el subcaracter macro de envío, que se define y función es la función de expansión, que determina por lo que se debe sustituir esta cadena de dos caracteres. Esta función debe tener tres argumentos: una corriente y un carácter, y un número (vd. nota; si así lo desea, prescinda el alumno de conocer el significado de este número, pero es un parámetro requerido). SET-DISPATCH-MACRO-CHARACTER devuelve T y como efecto lateral modifica el significado de READ. A partir de este momento, cuando READ encuente la combinación carácter-subcarácter la sustituirá por el resultado de aplicar la función. Por tanto (MAKE-DISPATCH-MACRO-CHARACTER #\z) => T (SET-DISPATCH-MACRO-CHARACTER #\z #\z #'(LAMBDA (CORRIENTE SUBCAR NUM) (LIST 'A 'B 'C))) => T 'zz => (A B C) 'za => Error: combinación ilegal z a Nótese que READ señala un error cuando encuentra una combinación carácter-subcarácter no definida. 'ZZ => ZZ 'zZ => (A B C) Nótese que en el subcarácter no se distingue entre mayúsculas y minúsculas, pero sí en el carácter. b) Agrupemos en una sola función HAZ-MI-READ-2 todas las modificaciones pedidas en este ejercicio y el anterior: (DEFUN HAZ-MI-READ-2 () (SET-MACRO-CHARACTER #\? #'(LAMBDA (CORRIENTE CARACTER)

Inteligencia Artificial e I.C.. 2002/2003

6.19

Dpto. Leng. Ciencias Comp.

(LIST 'VAR (READ CORRIENTE T NIL T)))) (MAKE-DISPATCH-MACRO-CHARACTER #\$) (SET-DISPATCH-MACRO-CHARACTER #\$ #\E #'(LAMBDA (CORRIENTE SUBCAR NUM) (LIST 'EXISTE (READ CORRIENTE T NIL T)))) (SET-DISPATCH-MACRO-CHARACTER #\$ #\U #'(LAMBDA (CORRIENTE SUBCAR NUM) (LIST 'PARA-TODO (READ CORRIENTE T NIL T))))) y ahora >(HAZ-MI-READ) T >'$E?X (EXISTE (VAR X)) >'$U ?X (PARA-TODO (VAR X)) NOTA: la función de expansión de un carácter macro de envío debe tener 3 parámetros: la corriente, el subcarácter y un número. Este número puede aparecer, como un natural en notación decimal, entre el carácter y el subcarácter. De esta forma los caracteres macros de envío tienen mayor flexibilidad. Si no hay ningún número, el tercer parámetro de la función de expansión se liga a NIL.

Inteligencia Artificial e I.C.. 2002/2003

6.20

Dpto. Leng. Ciencias Comp.

R.6.9. Manejo de errores (I). Implementar versiones de la función factorial tales que a) (FACTORIAL N) devuelva NIL cuando N no sea un número natural. b) (FACTORIAL N) señale un error y aborte la computación cuando N no sea un número natural. c) (FACTORIAL N) señale un error y aborte la computación cuando N no sea un número natural. Opcionalmente, si el argumento proporcionado es numérico, se calculará el factorial de un número “parecido” al dado: por ejemplo, el factorial de |n| si n es negativo, o de int(n) si n es fraccionario. d) (FACTORIAL N) señale un error y aborte la computación cuando N no sea un número natural. Opcionalmente, se solicitará al usuario un nuevo valor y se calculará el factorial de éste. ************************** SOLUCION: a) Partamos, por ejemplo, de la implementación recursiva ingenua: (DEFUN FACTORIAL (N) (COND ((ZEROP N) 1) (T (* N (FACTORIAL (1- N)))))) ¿Qué ocurre cuando FACTORIAL recibe un argumento inadecuado, por ejemplo, -9.9? Nunca se alcanzará el caso base y la recursión proseguirá hasta que se agota la memoria disponible. La forma más burda de evitar esto es la especificada en este apartado: (DEFUN FACT-EXTENDIDO (S) (COND ((NOT (NUMBERP S)) (PRINT 'ERROR) NIL) ((NOT (INTEGERP S)) (PRINT 'ERROR) NIL) ((MINUSP S) (PRINT 'ERROR) NIL) (T (FACTORIAL S)))) Y ahora será (FACT-EXTENDIDO 9.9)=> NIL escribéndose además el mensaje ERROR El lector debe ser consciente de que FACT-EXTENDIDO no implementa la función matemática factorial , sino una versión extendida de ella: factorial(X), si X es un número natural fact-extendido(X) = NIL, en otro caso. Ello puede llevar a errores algo difíciles de comprender. Por ejemplo, (* 2 (FACT-EXTENDIDO 9.9)) => Error: NIL no es un número. b) Por lo dicho en a), es mejor señalar explícitamente un error cuando el argumento no es adecuado. Para ello, CommonLisp proporciona la función ERROR: (ERROR cadena-control expresión*) Al intentar evaluar ERROR, se genera un mensaje de error –formateado según las reglas de FORMATque se envía a la corriente establecida para los mismos; se entra en el entorno de depuración. Todas las evaluaciones pendientes quedan abortadas y es imposible continuarlas. Según esto, la implementación pedida en este apartado será (DEFUN FACT-PROTEGIDO (S) (COND ((NOT (NUMBERP S)) (ERROR "~S no es un numero." S)) ((NOT (INTEGERP S)) (ERROR "~D no es entero." S)) ((MINUSP S) (ERROR "~D es negativo." S)) (T (FACTORIAL S)))) Y ahora tendremos: (FACT-PROTEGIDO 9.9) => Error: 9.9 no es entero. (* 2 (FACT-PROTEGIDO 9.9)) => Error: 9.9 no es entero.

Inteligencia Artificial e I.C.. 2002/2003

6.21

Dpto. Leng. Ciencias Comp.

NOTA. Es costumbre que los mensajes de error sean frases completas, acabadas con un punto. No es necesario mencionar en ellos la función en la que se produce el error, ya que se supone que el entorno del intérprete o compilador será capaz de añadir automáticamente esta información. c) Además de los errores irrecuperables empleados en b), el programador puede definir errores “continuables” o “recuperables”. Para ello, CommonLisp proporciona la función CERROR: (CERROR cadena-control1 cadena-control2 expresión*) Al intentar evaluar CERROR, se genera un mensaje de error –formateado según las reglas de FORMAT aplicadas a cadena-control2 y a expresión*- que se envía a la corriente establecida para los mismos. Además, se genera otro mensaje error –formateado según las reglas de FORMAT aplicadas a cadena-control1 y a expresión*- que informa al usuario de lo que ocurrirá si la computación no es abortada. Se entra en el entorno de depuración y el usuario puede elegir entre abortar las evaluaciones pendientes o continuar. Si elige continuar, CERROR devuelve NIL y se continúa normalmente con las evaluaciones pendientes. Según esto, la implementación pedida puede ser (DEFUN FACT-CERROR (S) (COND ((NOT (NUMBERP S)) (ERROR "~S no es un numero." S)) ((NOT (INTEGERP S)) (CERROR "Se calculara el factorial de INT(~D)." "~D no es entero." S) (FACT-CERROR (FLOOR S))) ((MINUSP S) (CERROR "Se calculara el factorial de |~D|." "~D es negativo." S) (FACTORIAL (- S))) (T (FACTORIAL S)))) Y ahora tendremos el siguiente diálogo (usuario en cursiva): > (FACT-CERROR –9) Error: -9 es negativo. Para continuar, teclee CONTINUE Se calculará el factorial de |-9|. CONTINUE 362880 Pero > (FACT-CERROR –9) Error: -9 es negativo. Para continuar, teclee CONTINUE Se calculará el factorial de INT(-9). ABORT > d) Lo que se pide podría implementarse mediante CERROR. Sin embargo, existe una manera más cómoda de hacerlo, empleando una forma ASSERT. (ASSERT expresión-test [(símbolo*) [cadena-control expresión*]]) Al intentar evaluar una forma ASSERT, se realiza el siguiente proceso: 1. Se evalúa expresión-test. Si es verdadera, ASSERT devuelve NIL y se continúa normalmente. 2. Si expresión-test es falsa, ASSERT señala un error y envía un mensaje de error indicando este hecho. 3. Si figura la lista (símbolo*), se proporciona al usuario la posibilidad de modificar el entorno vigente, asignando nuevos valores a cada uno de los símbolos de la lista. Si el usuario elige esta opción, se volverá al paso 1. 4. Si el usuario así lo elige, se abortarán las computaciones pendientes. Los argumentos cadena-control expresión* sirven para formar –según las reglas de FORMAT-el mensaje que se envía al usuario.

Inteligencia Artificial e I.C.. 2002/2003

6.22

Dpto. Leng. Ciencias Comp.

Por ejemplo, tras definir (DEFUN FACT-ASSERT1 (S) (ASSERT (AND (NUMBERP S) (INTEGERP S) (OR (ZEROP S) (PLUSP S)))) (FACTORIAL S)) se produce el siguiente diálogo: >(FACT-ASSERT1 -9) Error: la aserción (AND (NUMBERP S) (INTEGERP S) (OR (ZEROP S) (PLUSP S))) ha fracasado. Tras definir (DEFUN FACT-ASSERT2 (S) (ASSERT (AND (NUMBERP S) (INTEGERP S) (OR (ZEROP S) (PLUSP S))) (S)) (FACTORIAL S)) se produce el siguiente diálogo: >(FACT-ASSERT2 -9) Error: la aserción (AND (NUMBERP S) (INTEGERP S) (OR (ZEROP S) (PLUSP S))) ha fracasado. Teclee otra expresión para S: 9 362880 o bien >(FACT-ASSERT2 -9) Teclee otra expresión para S: ABORT Y tras definir (DEFUN FACT-ASSERT3 (S) (ASSERT (AND (NUMBERP S) (INTEGERP S) (OR (ZEROP S) (PLUSP S))) (S) "Lo siento, ~S no es un argumento valido para factorial." S) (FACTORIAL S)) El diálogo es >(FACT-ASSERT3 -9) Lo siento, -9 no es un argumento valido para factorial. Teclee otra expresión para S: 9 362880 NOTA. Es obvio que la forma concreta del diálogo entre sistema y usuario depende de la implementación del intérprete o compilador.

Inteligencia Artificial e I.C.. 2002/2003

6.23

Dpto. Leng. Ciencias Comp.

R.6.10. Manejo de errores (II). a) Implementar una versión de EVALQUOTE (vd. R.6.1.c) que nunca señale error. b) Implementar una versión de EVALQUOTE que nunca señale error, y además nunca salga del ciclo EVALQUOTE a causa de un error. c) Implementar una versión de EVALQUOTE que nunca señale error, y además salga del ciclo EVALQUOTE solamente a causa de los errores aritméticos. ************************** SOLUCION. En R.6.9 hemos aprendido a definir errores. En este ejercicio aprenderemos a programar el manejo de errores, tanto predefinidos como definidos por el programa. a) La siguiente forma CommonLisp nos permite realizar esto de una manera sencilla: (IGNORE-ERRORS expresión*) IGNORE-ERRORS evalúa sus expresiones secuencialmente y si no se producen errores devuelve el valor de la última. Por el contrario, si durante la evaluación se señala un error, IGNORE-ERRORS devuelve de manera inmediata NIL (y además el objeto error) y vuelve al nivel superior de interacción, sin entrar en el entorno de depuración. Nótese que el ámbito de IGNORE-ERRORS es dinámico, no léxico, es decir, los errores despreciados son aquellos que se producen durante la ejecución de expresión* o de cualquier otra expresión que se haya llamado desde ellas. Según esto, la función pedida será (DEFUN EEVALQUOTE0 () (IGNORE-ERRORS (PRINT 'EVALQUOTE>) (LET ((F (READ))) (COND ((EQ F 'EVAL>) NIL) (T (PRIN1 (APPLY F (READ))) (EEVALQUOTE0)))))) y ahora tendremos el siguiente diálogo: > (EEVALQUOTE0) EVALQUOTE> / (2 0) NIL # > b) CommonLisp permite manejar los errores de forma flexible. Para ello proporciona los siguientes recursos: -los errores son objetos Lisp (más concretamente, objetos CLOS de tipo condición). -existe una jerarquía predefinida de errores. -se puede programar explícitamente el manejador de cualquier clase de error, es decir, se pueden indicar las formas que se evaluarán cuando se señale un error de esa clase. Para esto último se emplea la forma HANDLER-CASE, que en su formato más sencillo es (HANDLER-CASE expresión {(tipo-error (símbolo) expresión*)}*) Se evalúa expresión (nótese que es exactamente una). Si durante su evaluación se señala un error de un tipo mencionado en una de las cláusulas (tipo-error expresión*), entonces se transfiere el control a las expresión* y símbolo se liga al objeto error señalado. Si el error satisface varios tipos, se transfiere el control a la primera de las cláusulas cuyo tipo lo satisfaga. tipo-error no se evalúa. . Nótese que el ámbito de HANDLER-CASE es dinámico, no léxico Según esto, podemos conseguir lo especificado con la siguiente definición: (DEFUN EEVALQUOTE1 () (HANDLER-CASE (PROGN (PRINT 'EVALQUOTE>) (LET ((F (READ))) (COND ((EQ F 'EVAL>) NIL)

Inteligencia Artificial e I.C.. 2002/2003

6.24

Dpto. Leng. Ciencias Comp.

(T (PRIN1 (APPLY F (READ))) (EEVALQUOTE1))))) (ERROR (CONDICION) (FORMAT T "Error ~S. ~%Se desprecia y se sigue en EVALQUOTE." CONDICION) (EEVALQUOTE1)))) y ahora el diálogo puede ser > (EEVALQUOTE1) EVALQUOTE> / (2 0) Error #. Se desprecia y se sigue en EVALQUOTE. EVALQUOTE> C) Nótese que no es necesario emplear un único manejador de errores, como se ha hecho en el apartado anterior. Para resolver el nuevo problema emplearemos dos (el segundo se empleará sólo si el primero no es aplicable al error señalado): (DEFUN EEVALQUOTE2 () (HANDLER-CASE (PROGN (PRINT 'EVALQUOTE>) (LET ((F (READ))) (COND ((EQ F 'EVAL>) NIL) (T (PRIN1 (APPLY F (READ))) (EEVALQUOTE2))))) (ARITHMETIC-ERROR (CONDICION) (FORMAT T "Error ~S. ~%Se desprecia y se sale de EVALQUOTE." CONDICION) 0) (ERROR (CONDICION) (FORMAT T "Error ~S. ~%Se desprecia y se sigue en EVALQUOTE." CONDICION) (EEVALQUOTE2)))) y ahora el diálogo puede ser > (EEVALQUOTE2) EVALQUOTE> CAR (2) Error #. Se desprecia y se sigue en EVALQUOTE. EVALQUOTE> / (2 0) Error #. Se desprecia y se sale de EVALQUOTE. 0 >

Inteligencia Artificial e I.C.. 2002/2003

6.25

Dpto. Leng. Ciencias Comp.

EJERCICIOS PROPUESTOS. P.6.1. Evaluar las siguientes expresiones, indicando los efectos laterales que se produzcan durante la evaluación: a) (READ X Y Z) b) (PRIN1 (LIST (READ) (READ) (READ))) c) (APPEND (QUOTE (READ)) (READ)) d) (PRINT (LIST 'TU 'NOMBRE 'ES (CADR (PRINT '(COMO TE LLAMAS?)) (READ)))) e) (PRINT (PRIN1 (PRINT (PRIN1 (+ 3 7))))) f) (PRINT (+ 3 (PRIN1 (PRIN1 (PRIN1 7))))) g) (+ 3 (PRINT (PRINT (PRINT (PRINT 7))))) h) (FORMAT T “¡Vaya lío! ~S” (+ 3 (PRINT (PRINT (PRINT (PRINT 7)))))) i) (FORMAT NIL “¡Vaya lío! ~S” (+ 3 (PRINT (PRINT (PRINT (PRINT 7))))))

P.6.2. Implementar la función VARIACIONES-FORMATO-1, que tiene un argumento numérico y lo escribe en pantalla en formato decimal sin parte decimal, decimal con 3 decimales, exponencial y hexadecimal.

P.6.3. Implementar las siguientes funciones: a) FUGA-DE-VOCALES, que tiene como argumento una cadena c y devuelve la cadena obtenida sustituyendo en c cada vocal por un *: (FUGA-DE-VOCALES “AeifghoU”) => “***fgh**” b) RESTAR-CADENAS, que tiene dos cadenas c1, c2 como argumentos, y devuelve la cadena obtenida quitando de c2 todas las apariciones como subcadena de la cadena c2: (RESTAR-CADENAS “ABCXYBAZABC” “AB”) => (CXYBAZC)

P.6.4. Implementar la función COPIAR(fich-origen fich-destino), cuyos argumentos son cadenas, que copia el fichero cuyo nombre es fich-origen en el fichero cuyo nombre es fich-destino.

P.6.5. Supóngase que queremos evitar que cierta cadena de caracteres c aparezca en un fichero de texto. Escribir la correspondiente función CENSURA(nombre-archivo cadena). Nótese que no basta eliminar las apariciones actuales de cadena, ya que al quitarlas pueden crearse otras nuevas: por ejemplo, al eliminar "AR" de "AARR" queda "AR", donde de nuevo aparece la cadena censurada.

P.6.7. a) Definir ? como un carácter macro, de manera que ?expresión1 expresión2 se lea como expresión2: >?PEPE '(A B C) (A B C) b) Ciertas aplicaciones MS-DOS escriben uno o varios ^Z al final del archivo. Sin embargo, READ no acepta este carácter como nombre de símbolo, ni lo reconoce como marca de final de archivo. Definir ^Z como carácter macro de forma que se evite este problema.

P.6.8. a) Definir ! como un carácter macro de envío y R como un subcarácter, de manera que !Rcadena se lea como el número cuya notación romana es cadena: >!RXVIII 18 b) Definir ! como un carácter macro de envío e I como un subcarácter, de manera que !Icadena se lea como el contenido del archivo cuyo nombre es cadena (se supone que el contenido del archivo es una sola expresión Lisp). P.6.9. a) Implementar versiones robustas de las funciones para el manejo de polígonos de R.2.8, de manera que señalen los errores adecuados cuando reciban argumentos que no sean de tipo correcto.

Inteligencia Artificial e I.C.. 2002/2003

6.26

Dpto. Leng. Ciencias Comp.

b) Implementar versiones de las mismas funciones, de forma que los errores sean recuperables, proporcionando al usuario la posibilidad de cambiar los argumentos proporcionados.

P.6.10. a) Implementar una versión de EVALQUOTE que procese adecuadamente las formas especiales. b) Implementar una versión de EVALQUOTE que desprecie los errores aritméticos y los de entrada/salida.

Inteligencia Artificial e I.C.. 2002/2003

6.27

Dpto. Leng. Ciencias Comp.

NOTAS ERUDITAS Y CURIOSAS. La función EVALQUOTE de R.6.1. tiene una larga historia en LISP. Hubo un tiempo en que muchos intérpretes interaccionaban de esa manera con el usuario; pero hace ya bastantes años que, debido a la falta de homogeneidad que introducen en el lenguaje, han ido cayendo en desuso. Como ha comprobado el alumno, no es demasiado difícil pasar del intérprete 'normal' (al a que se solía denomInar 'intérprete EVAL') al intérprete EVALQUOTE, y viceversa. En los viejos tiempos, la interacción con ficheros se llevaba a cabo mediante las típicas operaciones OPEN y CLOSE (que aún están disponibles en CommonLisp). Sin embargo, la manera más recomendable de llevarla a cabo es emplear WITH-OPEN-FILE, entre otras razones por el implícito UNWIND-PROTECT que lleva consigo. El manejo de errores es una de las cosas importantes que no se suelen contar en los cursos académicos de programación. El programador del mundo real, sin embargo, hará bien si emplea siempre versiones “seguras” o “protegidas” de sus procedimintos y funciones. Ello supone unas cuantas líneas de código y unos microsegundos adicionales de tiempo de ejecución, pero los beneficios obtenidos suelen compensar más que sobradamente estas molestias. CommonLisp es especialmente potente en cuanto al manejo de errores. La clase “error” se define como subclase de la más general “condición” y existe un amplio repertorio de funciones de bajo nivel para señalar y manejar condiciones. La contrapartida es que la especificación del lenguaje es complicada y a veces confusa para el lector inexperto. Como afirma Steele al hablar de la definición de condiciones [CLtL2, p.898], “...el lector debe tomarse esta sección con cierta precaución y dos aspirinas, y llamar a un hacker”.

Inteligencia Artificial e I.C.. 2002/2003

6.28

Dpto. Leng. Ciencias Comp.