[Arriba] [Índice general] [Índice] [ ? ]

Una Introducción a la Programación en Emacs Lisp

Esto es una Introducción a la Programación en Emacs Lisp, para personas que no son programadoras.
Edición 3.10, 28 October 2009
Copyright © 1990, 1991, 1992, 1993, 1994, 1995, 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.

Publicado por el:

 
GNU Press,                          Sitio Web: http://www.gnupress.org
una división de la                General: press@gnu.org
Free Software Foundation, Inc.      Ventas:  sales@gnu.org
51 Franklin Street, Fifth Floor     Tel: +1 (617) 542-5942
Boston, MA 02110-1301 USA           Fax: +1 (617) 542-2652

ISBN 1-882114-43-4

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; there being no Invariant Section, with the Front-Cover Texts being “A GNU Manual”, and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License”.

(a) The FSF’s Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom.”

Este menú maestro primero lista cada capítulo e indexa; entonces lista cada nodo en cada capítulo.

Escribiendo comandos de edición o C-x

C-e causa evaluación. 2.1 Nombres de Buffer  Buffers y ficheros son diferentes. 2.2 Obteniendo Buffers  Obteniendo un buffer por sí mismo, no solamente su nombre. 2.3 Cambiando Buffers  Cómo cambiar a otro buffer. 2.4 Tamaño de Buffer y la Localización del Punto  Dónde el punto está localizado y el tamaño del buffer. 2.5 Ejercicio 

Cómo Escribir Definiciones de Funciones

Una Vía acerca de Funciones Primitivas  3.1 La Forma Especial defun  La forma especial defun. 3.2 Instalar una Definición de Función  Instalar una definición de función. 3.3 Crear una Función Interactive  Creando una función interactive. 3.4 Opciones Diferentes para interactive  Opciones diferente para interactive. 3.5 Instalar Código Permanentemente  Instalando código permanentemente. 3.6 let  Creando e inicializando variables locales. 3.7 La Forma Especial if  ¿Y qué si? 3.8 Expresiones If–then–else  Expresiones If--then--else. 3.9 Verdad y Falsedad en Emacs Lisp  Que considera Lisp verdad y falsedad. 3.10 save-excursion  Guardando la traza del punto, la marca, y el buffer. 3.11 Revisar  3.12 Ejercicios 

Instalar una Definición de Función

El efecto de instalación  3.2.1 Cambiar una Definición de Función  Cómo cambiar una definición de función

Crear una Función Interactive

Un multiply-by-seven interactive, Un Resumen  Un resumen 3.3.1 Un multiply-by-seven Interactivo  La versión interactive.

let

• Previniendo la confusión  • Partes de la Expresión  • Ejemplo de Expresión let  3.6.3 Variables No Inicializadas en un Sentencia let 

La Forma Especial if

if en más detalle  3.7.1 La Función type-of-animal en Detalle  Un ejemplo de una expresión if.

Verdad y Falsedad en Emacs Lisp

Una explicación de nil  nil tiene dos significados.

save-excursion

Punto y Marca  Una revisión de varias localizaciones. 3.10.1 Plantilla para una Expresión save-excursion 

Unas pocas funciones de buffer relacionadas

4.1 Encontrando Más Información  Cómo encontrar más información. 4.2 Una Definición Simplificada beginning-of-buffer  Muestra goto-char, point-min, y push-mark. 4.3 La Definición de mark-whole-buffer  Casi lo mismo que beginning-of-buffer. 4.4 La Definición de append-to-buffer  Usa save-excursion y insert-buffer-substring. 4.5 Revisar  Revisa 4.6 Ejercicios 

La Definición de mark-whole-buffer

• resumen de mark-whole-buffer  4.3.1 Cuerpo de mark-whole-buffer  Solo tres líneas de código.

La Definición de append-to-buffer

Un Resumen de append-to-buffer  4.4.1 La Expresión Interactiva append-to-buffer  Una expresión interactiva de dos partes. 4.4.2 El Cuerpo de append-to-buffer  Incorpora una expresión let. 4.4.3 save-excursion en append-to-buffer  Cómo save-excursion trabaja.

Unas Pocas Funciones Más Complejas

5.1 La Definición de copy-to-buffer  Con set-buffer, get-buffer-create. 5.2 La Definición de insert-buffer  Solo lectura, y con or. 5.3 Definición Completa de beginning-of-buffer  Muestra goto-char, point-min, y push-mark. * Revisión Segundo Búffer Relacionado 5.5 Ejercicio de Argumento opcional 

La Definición de insert-buffer

• código insert-buffer  5.2.1 La Expresión Interactiva en insert-buffer  Cuando tu puedes leer, pero no escribir. 5.2.2 El Cuerpo de la Función insert-buffer  El cuerpo tiene un or y un let. 5.2.3 insert-buffer Con un if En vez de un or  Usando un if en vez de un or. 5.2.4 El or en el Cuerpo  Cómo la expresión or funciona. 5.2.5 La Expresión let en insert-buffer  Dos expresiones save-excursion. 5.2.6 Nuevo Cuerpo para insert-buffer 

La Expresión Interactiva en insert-buffer

Un Búffer de Solo lectura  Cuando un buffer no puede ser modificado. ‘b’ es una Expresión Interactiva  Un buffer existe o además su nombre.

Definición Completa de beginning-of-buffer

5.3.1 Argumentos Opcionales  5.3.2 beginning-of-buffer con un Argumento  Ejemplo con argumento opcional. 5.3.3 El beginning-of-buffer Completo 

beginning-of-buffer con un Argumento

• Rompe la obstrucción de beginning-of-buffer  Qué ocurre en búffer largo  Qué ocurre en un búffer pequeño 

Extendiendo y Encogiendo

Las Ventajas de Encoger  Las ventajas de la extender 6.1 La Forma Especial save-restriction  La forma especial save-restriction. 6.2 what-line  El número de la línea que apunta está activa. 6.3 Ejercicio Encogiendo 

car, cdr, cons: Funciones Fundamentales

Nombres Extraños  Un lado histórico: ¿por qué los nombres extraños? 7.1 car y cdr  Funciones para extraer parte de una lista. 7.2 cons  Construyendo una lista. 7.3 nthcdr  Llamando cdr repetidamente. 7.4 nth  7.5 setcar  Cambiando el primer elemento de una lista. 7.6 setcdr  Cambiando el resto de una lista. 7.7 Ejercicio 

cons

Construir una lista  7.2.1 Encuentra el tamaño de una Lista: length  Cómo encontrar el tamaño de una lista.

Cortando y Almacenando Texto

Almacenando Texto en una Lista  El texto está almacenado en una lista. 8.1 zap-to-char  Cortando texto a un carácter. 8.2 kill-region  Cortando texto de una región. 8.3 copy-region-as-kill  Una definición para copiar texto. 8.4 Disgresión dentro C  Nota menor en macros del lenguaje de programación C. 8.5 Inicializando una Variable con defvar  Cómo dar a una variable un valor inicial. • Revisión cons y search-fwd  8.7 Buscando Ejercicios 

zap-to-char

La Implementación Completa zap-to-char  La implementación completa. 8.1.1 La Expresión interactive  Una expresión interactiva de tres partes. 8.1.2 El Cuerpo de zap-to-char  Un resumen corto 8.1.3 La Función search-forward  Cómo buscar una cadena. 8.1.4 La Forma Especial progn  La forma especial progn. 8.1.5 Resumiendo zap-to-char  Usando point y search-forward.

kill-region

La Definición Completa kill-region  La definición de función. 8.2.1 condition-case  Tratando con un problema. 8.2.2 Macro Lisp 

copy-region-as-kill

La definición de la función completa copy-region-as-kill.  La definición completa de función. 8.3.1 El Cuerpo de copy-region-as-kill  El cuerpo de copy-region-as-kill.

El Cuerpo de copy-region-as-kill

last-command and this-command  • función kill-append  La función kill-new 

Inicializando una Variable con defvar

• Ver el valor de la variable actual  8.5.1 defvar y un asterisco 

Cómo las Listas se Implementan

• Listas diagramadas  9.1 Símbolos como una Caja con Cajones  Explorando una metáfora poderosa. 9.2 Ejercicio 

Pegando Texto

• Resumen del Anillo de la Muerte  10.2 La Variable kill-ring-yank-pointer  El anillo de la muerte es una lista. 10.3 Ejercicios con yank y nthcdr  La variable kill-ring-yank-pointer.

Bucles y Recursión

11.1 mientras  Causando una estrechez de código para repetir 11.2 Ahorra tiempo: dolist y dotimes  11.3 Recursión  Causando que una función se llame a sí mismo. 11.4 Ejercicio de Bucles 

mientras

Bucles con while  Repetir tantas veces como el test devuelva verdadero. 11.1.1 Un bucle while y una Lista  Un bucle while que usa una lista. 11.1.2 Un Ejemplo: print-elements-of-list  Usos while, car, cdr. 11.1.3 Un Bucle con un Contaje Incremental  Un bucle con un contador de incremento. • Incrementando Detalles de Bucles  11.1.4 Bucle con un contador Decrementando  Un bucle con un decrementando contador.

Detalles de un Bucle de Incremento

Ejemplo con contador incremental  Contando esquinas en un triángulo. Las partes de la definición de función  Las partes de la definición función. Poniendo la definición de la función junta  Poniendo la definición de función junta.

Bucle con un contador Decrementando

Ejemplo con el contador que se decrementa  Más piedras en la playa. Las partes de la definición de función  Las partes de la definición función. Poniendo la definición de la función junta  Poniendo la definición de función junta.

Ahorra tiempo: dolist y dotimes

La Macro dolist  La Macro dotimes 

Recursión

11.3.1 Construyendo Robots: Extendiendo la Metáfora  Mismo modelo, diferente número serie ... 11.3.2 Las Partes de una Definición Recursiva  Paseo hasta que tu pares ... 11.3.3 Recursión con una Lista  Usando una lista con el test si para recurso. • Función de triángulo recursivo  11.3.5 Ejemplo de Recursión Usando cond  11.3.6 Patrones Recursivos  Plantillas usadas con frecuencia. 11.3.7 Recursión sin Defermentos  No almacenar trabajo ... 11.3.8 No hay solución pospuesta 

Recursión en Lugar de un Contador

• Argumento de Ejemplo Recursivo de 1 o 2  Un argumento de 3 o 4 

Patrones Recursivos

Patrón Recursivo: cada  Patrón Recursivo: accumulate  Patrón Recursivo: keep 

Búsquedas de Expresiones Regulares

12.1 La Expresión Regular para sentence-end  La expresión regular para sentence-end. 12.2 La Función re-search-forward  Muy similar a search-forward. 12.3 forward-sentence  Un ejemplo sencillo de búsqueda con expresiones regulares. 12.4 forward-paragraph: una Mina de Oro de Funciones  Un ejemplo complejo de alguna cosa. 12.5 Crea tu propio fichero ‘TAGS’  Cómo crear tu propia tabla ‘TAGS’. 12.6 Revisar  12.7 Ejercicios con re-search-forward 

forward-sentence

• forward-sentence completo  Los bucles while  Dos bucles while. La búsqueda de expresiones regulares  Una búsqueda de expresión regular.

forward-paragraph: una Mina de Oro de Funciones

Definición de función forward-paragraph  Partes clave de la definición de la función. La expresión let*  La expresión let*. El bucle while hacia adelante  El bucle while con modo hacia adelante.

Contando: Repetición y Regexps

• Por qué Contar Palabras  13.1 La Función count-words-region  Usa un regexp, pero encuentra un problema. 13.2 Cuenta Palabras Recursivamente  Empezar con caso de no palabras en región. 13.3 Ejercicio: Contando Puntuación 

La Función count-words-region

Diseñando count-words-region  La definición usando un bucle while. 13.1.1 El Error de Espacio en Blanco en count-words-region  El Error de Espacio en Blanco en count-words-region.

Contando Palabras en una defun

Divide y Vencerás  14.1 ¿Qué Contar?  ¿Qué contar? 14.2 ¿Qué Constituye un Palabra o Símbolo?  ¿Qué constituye una palabra o símbolo? 14.3 La Función count-words-in-defun  Muy como count-words. 14.4 Contar Varias defuns Con un Fichero  Contando varias funciones en un fichero. 14.5 Encontrar un Fichero  ¿Quieres buscar en un fichero? 14.6 lengths-list-file en Detalle  Una lista de los tamaños de muchas definiciones. 14.7 Contar Palabras en defuns en Diferentes Ficheros  Contando en definiciones en diferentes ficheros. 14.8 Recursivamente Cuenta Palabras en Diferentes Ficheros  Recursivamente contando en diferentes ficheros. 14.9 Preparar los Datos para Mostrarlos en un Grafo  Preparar los datos para mostrarlos en un grafo.

Contar Palabras en defuns en Diferentes Ficheros

Determina las longitudes de defuns  Devolver una lista de tamaños de funciones. 14.7.1 La Función append  Adjuntar una lista a otra.

Preparar los Datos para Mostrarlos en un Grafo

El Dato para Mostrar en Detalle  14.9.1 Ordenando Listas  Ordenando listas. 14.9.2 Creando una Lista de Ficheros  Creando una lista de ficheros. 14.9.3 Contando definiciones de función 

Leyendo un Grafo

Imprimiendo las Columnas de un Grafo  15.1 La Función graph-body-print  Cómo imprimir el cuerpo de un grafo. 15.2 La Función recursive-graph-body-print  15.3 Necesidad para Ejes Impresos  15.4 Ejercicio 

Tu Fichero ‘.emacs’

• Configuración por defecto  16.1 Fichero de Inicialización Site-wide  Se puede escribir site-wide ficheros init. 16.2 Especificar Variables usando defcustom  Emacs escribirá código para ti. 16.3 Empieza por un Fichero ‘.emacs’  Cómo escribir un fichero .emacs. 16.4 Modo Texto y Auto Relleno  Corta líneas automáticamente. 16.5 Alias de Correo  Usar abreviaciones para direcciones de correo electrónico. 16.6 Indentar Modos de Tabulación  No usar tabulaciones con TeX 16.7 Algunos Atajos  Crear algunos atajos de teclado personales. 16.8 Mapas de teclado  Más acerca de atajos de teclado. 16.9 Cargando Ficheros  Cargar (por ej. evaluar) ficheros automáticamente. 16.10 Autoloading  Crear funciones disponibles. 16.11 Una Extensión Simple: line-to-top-of-window  Definir una función; enlazarla a una tecla. 16.12 Colores X11  Colores en X. 16.13 Configuraciones Misceláneas para un Fichero ‘.emacs’  16.14 Una Línea Modificada  Cómo personalizar tu mode line.

Depurando

17.1 depurar  Cómo usar el depurador construido. 17.2 debug-on-entry  Empezar depurando cuando se llama a una función. 17.3 debug-on-quit y (debug)  Empezar depurando cuando se sale con C-g. 17.4 El Depurador de Nivel de Fuentes edebug  Cómo usar Edebug, un depurador a nivel de fuentes. 17.5 Ejercicios de Depuración 

Manejando el Anillo de la Muerte

Qué hace el Anillo de la Muerte  B.1 La Función current-kill  B.2 pegar  Copiar una copia de un elemento clipeado. B.3 yank-pop  Insertar elemento apuntado. B.4 El Fichero ‘ring.el’ 

La Función current-kill

El código current-kill  current-kill en Outline 

current-kill en Outline

El cuerpo de current-kill  Disgresión acerca de la palabra ‘error’  Cómo confundir humanos, pero no ordenadores. Determinando el Elemento 

Un Grafo con Ejes Etiquetados

Grafo de Ejemplo Etiquetado  C.1 La Varlist print-graph  expresión let en print-graph. C.2 La Función print-Y-axis  Imprimir una etiqueta para los ejes verticales. C.3 La Función print-X-axis  Imprimir una etiqueta horizontal. C.4 Imprimiendo el Grafo Completo  La función para imprimir un grafo completo.

La Función print-Y-axis

La Función print-Y-axis en Detalle  ¿Qué altura se debería etiquetar?  ¿Qué altura para el eje Y? C.2.1 Viaje Lateral: Computa un Recuerdo  Cómo computar el recuerdo de una división. C.2.2 Construye un Elemento del Eje Y  Construir una línea para el eje Y. C.2.3 Crea un Eje de la Columna Y  Generar una lista de etiquetas del eje Y. C.2.4 La Versión No Demasiado Final de print-Y-axis  Una versión no muy final.

La Función print-X-axis

Similaridades y diferencias  Mucho como print-Y-axis, pero no exactamente. C.3.1 Eje X Marca Tic  Crear marcas de tic para los ejes horizontales.

Imprimiendo el Grafo Completo

Cambios para la Versión Final  Unos pocos cambios C.4.1 Testeando print-graph  Ejecutar un rápido test. C.4.2 Creando Gráficas de Números de Palabras y Símbolos  Ejecutando el código final. C.4.3 Una Expresión lambda: Anonimicidad Útil  Cómo escribir una función anónima. C.4.4 La Función mapcar  Aplicar una función a elementos de una lista. C.4.5 Otro Error … Más Insidioso  Todavía otro error … más insidioso. C.4.6 El Gráfico Impreso  ¡El grafo por sí mismo!
Prefacio   Qué buscas
1. Procesamiento de Listas   ¿Qué es Lisp?
2. Practicando Evaluación   Ejecutando varios programas.
3. Cómo Escribir Definiciones de Funciones   Cómo escribir definiciones de funciones.
4. Unas pocas funciones de buffer relacionadas   Explorando unas pocas funciones relacionadas con los búffers.
5. Unas Pocas Funciones Más Complejas   Unas pocas, incluso más complejas funciones.
6. Extendiendo y Encogiendo   Restringiéndote a tí y a Emacs a una región.
7. car, cdr, cons: Funciones Fundamentales   Funciones fundamentales en Lisp.
8. Cortando y Almacenando Texto   Eliminando texto y salvándolo.
9. Cómo las Listas se Implementan   Cómo las listas están implementadas en el ordenador
10. Pegando Texto   Pegando texto almacenado.
11. Bucles y Recursión   Cómo repetir un proceso.
12. Búsquedas de Expresiones Regulares   Búsquedas de expresiones regulares.
13. Contando: Repetición y Regexps   Una revisión de repetición y regexps.
14. Contando Palabras en una defun   Contando palabras en una defun.
15. Leyendo un Grafo   Un grafo prototipo imprimiendo una función.
16. Tu Fichero ‘.emacs’   Cómo escribir un fichero ‘.emacs’.
17. Depurando   Cómo ejecutar los depuradores de Emacs Lisp.
18. Conclusión   Ahora tienes las bases.
A. La Función the-the   Un apéndice: cómo encontrar palabras reduplicadas.
B. Manejando el Anillo de la Muerte   Un apéndice: cómo el kill ring funciona.
C. Un Grafo con Ejes Etiquetados   Como crear un grafo con ejes etiquetados.
D. Software Libre y Manuales Libres  
E. GNU Free Documentation License  
• Index  
Acerca del Autor   
 — El Listado Detalllado de Nodos —



Prefacio
¿Por qué Estudiar Emacs Lisp?   ¿Por qué aprender Emacs Lisp?
Leyendo este Texto   Leer, ganar familiaridad, escoger hábitos...
Para quien está esto escrito   Para quien es este escrito.
• Historia Lisp  
Una Nota para Novatos   Tu puedes leer esto como un novato
Gracias   
Procesamiento de Listas
1.1 Listas Lisp   ¿Qué son listas?
1.2 Ejecutar un Programa   Cualquier lista en Lisp es un programa listo para ejecutarse.
1.3 Generar un Mensaje de Error   Generando un mensaje de error.
1.4 Nombres de símbolos y Definiciones de Funciones   Nombres de símbolos y definiciones de función.
1.5 El Intérprete Lisp   Qué hace el intérprete Lisp.
1.6 Evaluación   Ejecutando un programa.
1.7 Variables   Devolviendo un valor desde una variable.
1.8 Argumentos   Pasando información a una función.
1.9 Configurando el Valor de una Variable   Configurando el valor de un variable.
1.10 Resumen   Los mayores puntos.
1.11 Ejercicios   
Listas Lisp
Números, Listas dentro de Listas   Lista tener números, otras listas, en ellas.
1.1.1 Átomos Lisp   Entidades Elementales.
1.1.2 Espacios en blanco en Listas   Formatenado listas para ser legibles.
1.1.3 GNU Emacs te Ayuda a Escribir Listas   Cómo GNU Emacs te ayuda a escribir listas. 
El Intérprete Lisp
Complicaciones   Variables, formas especiales, Listas.
1.5.1 Compilación de Bytes   Especialmente procesando código por la velocidad. 
Evaluación
Cómo el Intérprete Actúa   Devolver y Efectos Colaterales...
1.6.1 Evaluando Listas Propias   Listas con listas... 
Variables
• Ejemplo de fill-column  
1.7.1 Mensaje de Error para un Símbolo sin una Función   El mensaje de error para un símbolo sin una función.
1.7.2 Mensaje de Error para un Símbolo sin un Valor   El mensaje de error para un símbolo sin un valor. 
Argumentos
1.8.1 Tipos de Argumentos de Datos   Tipos de datos pasados a una función.
1.8.2 Un Argumento como el Valor de una Variable o Lista   Un argumento puede ser el valor de una variable o lista.
1.8.3 Número de Variables de Argumentos   Algunas funciones pueden tomar un número variable de argumentos.
1.8.4 Usando el Tipo Incorrecto de Objeto como un Argumento   Pasando un argumento del tipo incorrecto a una función.
1.8.5 La función message   Una función útil para enviar mensajes. 
Configurando el Valor de una Variable
1.9.1 Usando set   Configurando valores.
1.9.2 Usando setq   Configurando un valor citado.
1.9.3 Contando   Usando setq para contar. 
Practicando Evaluación
Cómo Evaluar  
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Prefacio

La mayoría del entorno integrado GNU Emacs está escrito en el lenguaje de programación llamado Emacs Lisp. El código escrito en este lenguaje de programación es el software---el conjunto de instrucciones---que cuenta el ordenador que hacer cuando tu le das comandos. Emacs está diseñado así que tu puedes escribir nuevo código en Emacs Lisp y fácilmente instalarlo como una extensión al editor.

(GNU Emacs es algunas veces llamado un ``editor extensible'', pero hace mucho más que proporcionar capacidad de edición. Es mejor referirse a Emacs como un ``entorno de computación extensible''. Sin embargo, esta frase es clara y cristalina. Es fácil referirse a Emacs simplemente como un editor. Más allá cada cosa que haces en Emacs---encontrar la fecha Maya y fases de la luna, simplificar polinomios, depurar código, administrar ficheros, leer cartas, escribir libros---todas estas actividades son tipos de edición en la mayoría del sentido general del mundo.)

¿Por qué Estudiar Emacs Lisp?   ¿Por qué aprender Emacs Lisp?
Leyendo este Texto   Leer, ganar familiaridad, escoger hábitos...
Para quien está esto escrito   Para quien es este escrito.
• Historia Lisp  
Una Nota para Novatos   Tu puedes leer esto como un novato
Gracias  
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

¿Por qué Estudiar Emacs Lisp?

Aunque Emacs Lisp normalmente se asocia solo con Emacs, es un lenguaje de programación completo. Se puede usar Emacs Lisp como harías con cualquier otro lenguaje de programación.

Quizás se quiere comprender la programación; quizás se quiere extender Emacs; o quizás se quiere llegar a ser un programador. Esta introducción a Emacs Lisp está diseñado para iniciarse: para ser guiado en el aprendizaje de los fundamentos de programación, y de manera más importante, para mostrar como enseñar a ir más allá.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Leyendo este Texto

A través de este documento, se verá un pequeño ejemplo de programas que se pueden ejecutar dentro de Emacs. Si se lee este documento en Info dentro de GNU Emacs, se pueden ejecutar los programas como ellos aparecen. (Esto es fácil de hacer y se explica cuando los ejemplos se presentan). Alternativamente, se puede leer esta introducción como un libro impreso mientras se está sentando con un ordenador ejecutando Emacs. (Esto es lo que me gusta hacer; me gustan los libros impresos.) Si no se está ejecutando Emacs, todavía se puede leer este libro, pero en este caso, lo mejor es tratarlo como una novela, o como una guía para un país no visitado todavía: interesante, pero no es lo mismo allí.

Mucha de esta introducción se dedica a paseos guiados de código usando en GNU Emacs. Estos paseos están diseñados para dos propósitos: primero, dar familiaridad con código real que funciona (código que se usa cada día); y, segundo, dar familiaridad con el camino de Emacs funcionando. Es interesante ver cómo un entorno en funcionamiento se implementa. También, espero que se escoja el hábito de navegar a través del código fuente. Se puede aprender desde él para muchas ideas. Tener GNU Emacs es como tener una cueva del dragón de los tesoros.

Además de aprender acerca de Emacs como un editor y Emacs Lisp como un lenguaje de programación, las guías de ejemplos guiados te darán una oportunidad para haber adquirido con Emacs como un entorno de programación Lisp. GNU Emacs soporta programación y provee herramientas que querrán llegar a ser confortables usando cosas como M-. (la clave que invoca el comando find-tag). Tu también aprenderás acerca de búffers y otros objetos que son parte del entorno. Aprendiendo acerca estas funcionalidades de Emacs es como aprender nuevas rutas alrededor de tu hogar.

Finalmente, son convenientes algunas habilidades usando Emacs para aprender aspectos de programación que no se conocen. Con frecuencia se puede usar Emacs para ayudar a comprender qué puzzles encontrar o como hacer alguna cosa nueva. Esta auto-confianza no es solo un placer, también es una ventaja.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Para quien está esto escrito

Este texto está escrito como una introducción elemental para gente que no son programadores. Si eres un programador, puedes no estar satisfecho con este libro. La razón es que puedes tener que llegar a ser experto leyendo manuales de referencia y eso no es el camino por el que este texto está organizado.

Un programador experto que revisó este texto me dijo a mí:

Yo prefiero aprender desde manuales de referencia. Yo ``escarbo'' cada párrafo, y ``vienen por aire'' entre párrafos.

Cuando tengo el fin de un párrafo, asomo que este asunto está hecho, finalizado, que conozco cada cosa que necesito (con la posible excepción del caso cuando el siguiente párrafo empieza hablando acerca de eso en más detalle). Yo espero que un manual de referencia bien escrito no tendrá un montón de redundancia, y tendrá excelentes punteros a (un) lugar donde la información que yo quiero está.

¡Esta introducción no está escrita para esta persona!

Primeramente, yo intento decir cada cosa al menos tres veces: primero, introducirlo; segundo, mostrarlo en contexto; y tercero, mostrarlo en un contexto diferente, o revisarlo.

Segundo, yo duramente siempre pongo toda la información acerca de un asunto en un lugar, mucho menos en un párrafo. Para mi camino de pensamiento, se impone una carga bastante fuerte en el lector. En vez de eso yo intento explicar solo que necesitas saber en el momento. (Algunas veces incluyo una pequeña información extra así no se sorprenderá más tarde cuando la información adicional se introduzca formalmente.)

Cuando se lea este texto, no se espera que aprender cada cosa la primera vez. Frecuentemente, tu solo necesitas hacer, como estaba, un `reconocimiento' con alguno de los elementos mencionados. Mi esperanza es que yo tenga estructurado el texto y dar suficientes indicios que estarán alerta para que es importante y concentrarse en ellos.

Se necesita ``escabar dentro'' de algunos párrafos; no hay otro modo para leerlos. Pero yo he intentado guardar el número de tales párrafos. Este libro pretende como una colina que se acerca, en vez de una montaña.

Esta introducción para Programación en Emacs Lisp tiene un documento complementario. (El Manual de Referencia de GNU Emacs Lisp)Arriba. El manual de referencia tiene más detalles que esta introducción. En el manual de referencia, toda la información sobre un asunto está concentrado en un lugar. Se debe cambiar si se es como el programador citado arriba. Y, de acuerdo, después de que se ha leido esta Introducción, se encontrará el Manual de Referencia útil cuando estás escribiendo tus propios programas.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Historia de Lisp

Lisp fué desarrollado primero en los 50 en el Instituto Tecnológico de Massachusetts para investigar en inteligencia artificial. El gran poder del lenguaje Lisp lo hace superior para otros propósitos también, tal como escribir comandos de edición y entornos integrados.

GNU Emacs Lisp está fuertemente inspirado en Maclisp, que está escrito en el MIT en los sesenta. Está en cierto modo inspirado en Common Lisp, que llega a ser un estándar en los 80. Sin embargo, Emacs Lisp es mucho más simple que Common Lisp. (La distribución estándar de Emacs contiene un fichero de extensiones opctional, ‘cl.el’, que añade muchas funcionalidades a Emacs Lisp.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Una Nota para Novatos

Aunque no se conozca GNU Emacs, se puede leer este documento de manera útil. Sin embargo, es mejor aprender Emacs, al menos aprender a moverse alrededor de la pantalla del ordenador. Se puede aprender por uno mismo cómo usar así Emacs con el tutorial on-line. Para usarlo, se debe escribir C-h t. (Esto significa que se presione la tecla <CTRL> y la h al mismo tiempo, y después se presiona t

Con frecuencia, me refiero a uno de los comandos de Emacs estándar listando las teclas que se presionan para invocar el comando y entonces dar el nombre del comando entre paréntesis, como este: M-C-\\ (indent-region). (Si lo deseas, se pueden cambiar las teclas que son escritas para invocar el comando; esto se llama rebinding. Véase la sección Mapas de Teclado.) La abreviación M-C-\\ significa que se escribe la tecla <META>, <CTRL>, y <\\> todo al mismo tiempo. (En muchos teclados modernos la tecla <META> es etiquetada con <ALT>.) Algunas veces una combinación como esta es llamada keychord, puesto que es similar al camino de tocar un acorde en un piano. Si tu teclado no tiene una tecla <META>, la tecla con prefijo <ESC> es usado en lugar de ella. En este caso M-C-\\ significa que se presiona <ESC> y entonces escribe <CTRL> y la tecla <\\> al mismo tiempo. Pero normalmente M-C-\\ significa presionar la tecla <CTRL> alrededor con la tecla que está etiquetada <ALT> y, al mismo tiempo, se presiona la tecla <\\>.

Además escribiendo una sola tecla, se puede prefijar que escribes con C-u, que es llamado el `argumento universal'. La tecla C-u pasa un argumento para el comando subsiguiente. De este modo, para indentar una región de texto plano a 6 espacios, se marca la región, y entonces se escribe C-u 6 M-C-\\. (Si no se especifica un número, Emacs pasa el número 4 al comando o de otra manera ejecuta el comando de manera diferente). Véase (emacs)Argumentos sección `Argumentos Numéricos' en El Manual de GNU Emacs.

Si se está leyendo esto en Info usando GNU Emacs, se puede leer a través este documento completo solo presionando la barra de espacio, <SPC>. (Para aprender acerca de Info, escribe C-h i y entonces selecciona Info.)

Una nota en terminología: cuando yo uso la palabra Lisp sola, con frecuencia me estoy refiriendo a los dialectos de Lisp en general, pero cuando yo hablo de Emacs Lisp, yo estoy refiriéndome a GNU Emacs Lisp en particular.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Gracias

Gracias a todos quienes me ayudaron con este libro. Especialmente agradecido a Jim Blandy, Noah Friedman, Jim Kingdon, Roland McGrath, Frank Ritter, Randy Smith, Richard M. Stallman, and Melissa Weisshaus. Gracias también a Philip Johnson y David Stampe por su for ánimo paciente. Mis errores son míos.

Robert J. Chassell bob@gnu.org

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1. Procesamiento de Listas

Para las personas nuevas, Lisp es un lenguaje de programación extraño. En código Lisp hay paréntesis en cada lugar. Algunas personas incluso reclaman que el nombre signfica `Lots of Isolated Silly Parentheses' (`Montones de Paréntesis Aislados Estúpidos'). Pero la advertencia es sin garantías. Lisp es para Procesamiento de Listas, y el lenguaje de programación maneja listas (y listas de listas) poniéndolas entre paréntesis. Los paréntesis marcan los límites de la lista. Algunas veces una lista es precedida por un apóstrofe simple o una marca de cita, ‘'’(1) Las listas son las bases de Lisp.

1.1 Listas Lisp   ¿Qué son listas?
1.2 Ejecutar un Programa   Cualquier lista en Lisp es un programa listo para ejecutarse.
1.3 Generar un Mensaje de Error   Generando un mensaje de error.
1.4 Nombres de símbolos y Definiciones de Funciones   Nombres de símbolos y definiciones de función.
1.5 El Intérprete Lisp   Qué hace el intérprete Lisp.
1.6 Evaluación   Ejecutando un programa.
1.7 Variables   Devolviendo un valor desde una variable.
1.8 Argumentos   Pasando información a una función.
1.9 Configurando el Valor de una Variable   Configurando el valor de un variable.
1.10 Resumen   Los mayores puntos.
1.11 Ejercicios  
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.1 Listas Lisp

En Lisp, una lista como esto: '(rose violet daisy buttercup). Esta lista es precedida por un apóstrofe simple. Podría estar bien escrita como sigue, que mira más como el tipo de lista con la que estás familiarizado:

 
'(rose
  violet
  daisy
  buttercup)

Los elementos de esta lista son los nombres de las 4 flores diferentes, separadas por espacios en blanco y alrededor de paréntesis, como flores en un campo con un muro de piedras alrededor de ellas.

Números, Listas dentro de Listas   Lista tener números, otras listas, en ellas.
1.1.1 Átomos Lisp   Entidades Elementales.
1.1.2 Espacios en blanco en Listas   Formatenado listas para ser legibles.
1.1.3 GNU Emacs te Ayuda a Escribir Listas   Cómo GNU Emacs te ayuda a escribir listas.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Números, Listas dentro de Listas

Las listas pueden también tener números dentro, como en esta lista: (+ 2 2). Esta lista tiene un signo más, ‘+’, seguido por dos ‘2’, cada uno separado por espacios en blanco.

En Lisp, datos y programas están representados por el mismo camino; que son ambas listas de palabras, números, u otras listas, separadas por espacios en blanco y alrededor de paréntesis. (Desde que un programa mira como datos, un programa puede fácilmente servir como datos para otros; esta es una funcionalidad muy poderosa de Lisp.) (Incidentalmente, estas dos marcas de paréntesis no son listas Lisp, porque ellos contienen ‘;’ y ‘.’ como marcas puntuación.)

Aquí está otra lista, esta vez con una lista dentro:

 
'(esta lista tiene (una lista dentro))

Los componentes de esta lista son las palabras ‘esto’, ‘lista’, ‘tiene’, y la lista ‘(una lista dentro de ella)’. La lista interior es hecha de las palabras ‘a’, ‘lista’, ‘dentro’, ‘de’, ‘ello’.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.1.1 Átomos Lisp

En Lisp, hemos estado llamando a las palabras átomos. Este término viene desde el significado de la palabra átomo, que significa indivisible. Tan lejos como Lisp es concebido, las palabras que hemos estado usando en las listas no pueden ser divididas dentro de pequeñas partes y todavía significan la misma cosa como parte de un programa; como con números y caracteres de símbolos simples como ‘+’. Por otro lado, no como un antiguo átomo, una lista puede ser dividida en pequeñas partes. Ver (Funciones Fundamentales)car cdr & cons.

En una lista, los átomos son separados de otros por espacios en blanco. Ellos pueden estar a la derecha y seguir a un paréntesis.

Técnicamente hablando, una lista en Lisp consiste de paréntesis alrededor de átomos separados por espacios en blanco o alrededor de otras lista o alrededor de ambos átomos u otras listas. Una lista puede tener solo un átomo en ella o no tener nada en ella para todo. Una lista con nada dentro se ve como esto: (), y está llamado la lista vacía. No como cualquier otra cosa, un lista vacía es considerad ambos un átomo y una lista al mismo tiempo.

La representación impresa de ambos átomos y listas son llamadas expresiones simbólicas o, más concisamente, s-expresiones. La palabra expresión por sí mismo puede referir o bien la representación impresa, o para el átomo o la lista como ella es manejada internamente en el ordenador. Con frecuencia, la personas usan el término expresión indiscriminadamente. (También, en muchos textos, la palabra forma es usada como un sinónimo para la expresión.)

Incidentalmente, los átomos que hacen que nuestro universo fuese nombrado así cuando ellos fueron pensados para ser indivisibles; pero han sido encontrados átomos físicos que no son indivisibles. Las partes pueden dividir un átomo o puede fisionarse en 2 partes de igual tamaño. Los átomos físicos fueron nombrados prematuramente, antes de que su verdadera naturaleza fuese encontrada. En Lisp, ciertos tipos de átomos, como un array, pueden ser separados en partes; pero el mecanismo de hacer esto es diferente de el mecanismo para dividir una lista. Tan lejos como las operaciones de las listas son concebidas, los átomos de una lista son indivisibles.

Como en Inglés, los significado de las letras de componentes de un átomo Lisp son diferentes desde el significado de las letras que crean una palabra. Por ejemplo, la palabra Suramericana ‘ai’, es completamente diferente de las dos palabras ‘a’, e ‘i’.

Hay muchos tipos de átomos naturales, pero solo unos pocos en Lisp: por ejemplo, números, tales como 37, 511, o 1729, y símbolos, tales como ‘+’, ‘foo’, o ‘forward-line’. Las palabras que hemos listado en los ejemplos de debajo son todos símbolos. Cada día de conversación Lisp, la palabra ``átomo'' no es usada con frecuenca, porque los programadores normalmente intentan ser más específicos acerca de que tipo de átomo están tratando. La programación Lisp es sobre todo de símbolos (y algunas veces números) con listas. (De ese modo, tres palabras rodeadas de paréntesis son una apropiada lista en Lisp, desde que ello consiste en átomo, que en este caso son símbolos, separados por espacios en blanco y cerrados por paréntesis, sin cualquier puntuación no Lisp.)

Texto entre comillas --- incluso frases de párrafos --- son también un átomo. Aquí hay un ejemplo:

 
'(esta lista incluye "texto entre comillas.")

En Lisp, todo el texto citado incluyendo la marca de puntuación y los espacios en blanco son un átomo simple. Este tipo de átomo es llamado string (por `cadena de caracteres') y es el tipo de cosa que es usada para mensajes que un ordenador puede imprimir para que un humano lea. Las cadenas son un tipo diferente de átomo en vez de números, o símbolo y son usados de manera diferente.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.1.2 Espacios en blanco en Listas

La cantidad de espacios en blanco en una lista no importa. Desde el punto de vista del lenguaje Lisp,

 
'(esta lista
   parece esto)

es exactamente lo mismo que esto:

 
'(esta lista parece esto)

Ambos ejemplos muestran que Lisp es la misma lista, la lista hecha de los símbolos ‘esta’, ‘lista’, ‘parece’, y ‘esto’ en este orden.

Espacios en blanco extra y nuevas líneas son diseñadas para crear una lista más legible por humanos. Cuando Lisp lee la expresión, asimila los espacios en blanco extra (pero necesita tener al menos un espacio entre átomos en orden para contarlos aparte.)

Aunque parezca raro, los ejemplos que hemos visto cubren casi todo lo que Lisp tiene. Cualquier otra lista en Lisp ve más o menos como uno de estos ejemplos, excepto que la lista puede ser más large y más compleja. En resumen, una lista está entre paréntesis, una cadena está entre comillas, un símbolo parece como una palabra, y un número parece un número. (Para ciertas situaciones, corchetes, puntos y otros caracteres especiales pueden ser usados; sin embargo; iremos bastante lejos sin ellos.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.1.3 GNU Emacs te Ayuda a Escribir Listas

Cuando escribes una expresión Lisp en GNU Emacs usando bien el modo de Interacción Lisp o el modo Emacs Lisp, tu tienes disponible varios comandos para formatear la expresión Lisp, de modo que es fácil de leer. Por ejemplo, presionando la tecla <TAB> automáticamente indenta la línea del cursor que está por la cantidad correcta. Un comando para indentar apropiadamente el código en una región está asociado a M-C-\. La indentación está diseñada de manera que puedes ver que elementos de una lista pertenencen a qué lista --- los elementos de una sublista están más indentados que los elementos de una lista cerrada.

Además, cuando se escribe un paréntesis de cierra, Emacs momentáneamente salta el cursor atrás para hacer el matching (emparejamientos) con el paréntesis de apertura, para ver cuál es. Esto es muy útil, ya que cada lista que escribes en Lisp debe tener sus paréntesis emparejados con sus paréntesis de apertura. (Ver Modos Mayores: (El Manual de GNU Emacs)Modos Mayores, para más información acerca de modos de Emacs.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.2 Ejecutar un Programa

Una lista en Lisp ---cualquier lista--- es un programa listo para ser ejecutado. Si lo ejecutas (lo que la jerga Lisp llama evaluar), el ordenador hará una de las tres cosas: nada excepto devolverte la lista misma; enviar un mensaje de error; o, tratar el primer símbolo en la lista como un comando para hacer alguna cosa. (Normalmente, es el último de estas tres cosas de lo que realmente se quiere).

El apóstrofe, ', que se pone enfrente de algún ejemplo de listas en secciones precedentes se llama quote; (comilla); cuando precede una lista, Lisp no tiene que hacer nada con la lista, otra que la toma como está escrita. Pero si no hay una cita precediendo la lista, el primer ítem de la lista es especial: es un comando para que el ordenador obedezca. (En Lisp, estos comandos son llamados funciones.) La lista (+ 2 2) muestra debajo que no tuvo un quote en frente, así Lisp comprende que + es una instrucción para hacer alguna cosa con el resto de la lista: añadir los números que siguen.

Si estás leyendo esto dentro de GNU Emacs en Info, aquí está como puedes evaluar una lista: posiciona tu cursor de manera inmediata después de la siguiente lista y escribe C-x C-e:

 
(+ 2 2)

Verás que el número 4 aparece en el área echo. (La jerga que se usa es ``evaluar la lista.'' El área echo es la línea arriba de la pantalla que muestra o hace ``echo'' del texto.) Ahora intenta la misma cosa con una lista entre comillas: posiciona el cursor correcto después de la siguiente lista y escribe C-x C-e:

 
'(esto es una lista comilla)

Tu verás (esto es una lista citada) aparece en el área echo.

En ambos casos, lo que estás haciendo es dar un comando al programa dentro de GNU Emacs llamado intérprete Lisp --- dando al intérprete un comando para evaluar la expresión. El nombre del intérprete Lisp viene de la palabra para la tarea hecha por un humano que viene con el significado de una expresión --- quien lo ``interpreta''.

También se puede evaluar un átomo que no es parte de una lista --- uno que no está rodeado por paréntesis; de nuevo, el intérprete Lisp traduce desde la expresión humanamente legible al lenguaje del ordenador. Pero antes de discutir esto (ver Variables), nosotros discutiremos lo que el intérprete de Lisp hace cuando tu creas el error.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.3 Generar un Mensaje de Error

No se preocupe si genera un mensaje de error de manera accidental, se da un comando para que el intérprete de Lisp lo genere. Esto es una actividad sin daño; y en efecto, con frecuencia se intenta generar mensajes de error de manera intencional. Una vez se comprende la jerga, los mensajes de error pueden ser informativos. En vez de ser llamados mensajes de ``error'', deberían ser llamados mensajes de ``ayuda''. Esto son como signos para un viajero en un país extraño; descifrarlos puede ser duro, pero una vez comprendidos, pueden apuntar el camino.

El mensaje de error está generado por un depurador de GNU Emacs. Se `introduce el depurador'. Se obtiene el depurador escribiendo q.

Lo que se hace es evaluar una lista que no está citada y no tiene un comando con significado como su primer elemento. Aquí hay una lista casi exacta a la usada, pero sin la cita simple en vez de eso. Posicione el cursor derecho después y escribe C-x C-e:

 
(esto es una lista sin cita)

Lo que ves depende de qué versión de Emacs se está ejecutando. GNU Emacs versión 22 provee más información que la versión 20 y anterior. Primero, el resultado más reciente genera un error; que en la versión 20 funciona.

En GNU Emacs versión 22, una ventana ‘*Backtrace*’ se abrirá y se verá lo siguiente:

 
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function this)
  (this is an unquoted list)
  eval((this is an unquoted list))
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Su cursor estará en esta ventana (puedes tener que esperar unos pocos segundos antes de llegar a ser visible). Para salir del depurador y de su ventana, escribe:

 
q

Por favor, escribe q bien ahora, así llegará a ser confidente de que se pueda bajar el depurador. Entonces, escribe C-x C-e de nuevo y se reintroduce.

Basado en lo que ya se sabe, se puede leer este mensaje de error.

Si se lee el búffer ‘*Backtrace*’ desde arriba; cuenta lo que Emacs hace. Cuando se escribe C-x C-e, se hizo una llamada interactiva el comando eval-last-sexp. eval es una abreviación para `evaluar' y sexp es una abreviación para la `expresión simbólica'. El comando significa `evalúa la última expresión simbólica', que es la expresión ahora antes de tu cursor.

En cada línea de abajo se cuenta lo que evaluó el siguiente intérprete. La acción más reciente está alta. El búffer es llamado ‘*Backtrace*’ porque te permite habilitar la traza de Emacs hacia atrás.

Arriba del búffer ‘*Backtrace*’, se verá la línea:

 
El depurador introdujo el error Lisp: (void-function this)\n

El intérprete Lisp intentó evaluar el primer átomo de la lista, la palabra ‘this’. Esta acción que generaba el mensaje de error ‘void-function this’.

El mensaje contiene las palabras ‘void-function’ y ‘this’.

La palabra ‘function’ fué mencionada antes. Es una palabra muy importante. Para nuestros propósitos, se puede definir eso diciendo que una función (function) es un conjunto de instrucciones para el ordenador que cuenta al ordenador hacer alguna cosa.

Ahora se puede empezar a comprender el mensaje de error: ‘void-function this’. La función (que es, la palabra ‘this’) no tiene una definición de cualquier conjunto de instrucciones del ordenador para llevarlo.

La palabra ligeramente extraña, ‘void-function’, está diseñada para cubrir el camino que Emacs Lisp está implementado, que es cuando un símbolo no tiene una definición de función adjunta a eso, el lugar que contendría las instrucciones es `vacío'.

Por otro lado, desde que fuimos capaces de añadir 2 más 2 de manera exitosa, evaluando (+ 2 2), se puede inferir que el símbolo + debe tener un conjunto de instrucciones para que el ordenador obedezca y estas instrucciones deben añadir los números que siguen el +.

En la versión 20 de GNU Emacs, y versiones tempranas, verás solo una línea del mensaje de error, aparecerá el área echo y mira como esto:

 
La definición de la función de símbolos está
vacía: esta

(También, tu terminal puede avisar para hacer algo, o no. Esto es solo un dispositivo para atraer tu atención.) El mensaje va fuera tan pronto como tu escribes otra tecla, incluso para mover el cursor.

Conocemos el significado de la palabra ‘Símbolo’. Se refiere al primer átomo de la lista, la palabra ‘este’. La palabra ‘función’ se refiere a las instrucciones que cuentan al ordenador que hacer. (Técnicamente, el símbolo cuenta al ordenador donde encontrar las instrucciones, pero esto es una complicación que podemos ignorar por el momento.)

El mensaje de error puede ser comprendido: ‘La definición del símbolo está vacío: este’. El símbolo (que es, la palabra ‘este’) le faltan instrucciones para que el ordenador funcione.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.4 Nombres de símbolos y Definiciones de Funciones

Se puede articular otra característica de Lisp basada en lo que se discutió hace tiempo---una característica importante: un símbolo, como +, no es en sí mismo el conjunto de instrucciones que el ordenador transmite. En vez de eso, el símbolo está usado, quizás temporalmente, como un camino de localizar la definición o conjunto de instrucciones. Lo que se ve es el nombre a través del que las instrucciones se pueden encontrar. Los nombres de personas trabajan por el mismo camino. Puede ser llamado ‘Bob’; sin embargo, no soy ‘B’, ‘o’, ‘b’ pero soy, o fuí, la consciencia consistente asociada con una forma de línea particular. El nombre no soy yo, pero puedo ser usado para referirme a mí.

En Lisp, un conjunto de instrucciones puede adjuntarse a varios nombres. Por ejemplo, las instrucciones de ordenador para añadir números pueden ser enlazados al símbolo más tan bien como el símbolo + (y son en algunos dialectos de Lisp). Entre humanos, puede referirse a ‘Robert’ tan bien como ‘Bob’ y en otras palabras también.

Por otro lado, un símbolo puede tener solo una función adjunta en un momento. De otro modo, el ordenador estaría confundido acerca de qué definición usar. Si este fuera el caso, solo una persona en el mundo podría llamarse ‘Bob’. Sin embargo, la definición de función para la que el nombre se refiere puede ser cambiada de manera legible. (Ver Instalar una Definición de Función.)

Desde que Emacs Lisp es grande, es costumbre nombrar símbolos de un modo que identifique la parte de Emacs de la función que pertenece. De este modo, todos los nombres de funciones que tratan con Texinfo empiezan con ‘texinfo-’ y estas funciones que tratan con la lectura de correo empiezan con ‘rmail-’.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.5 El Intérprete Lisp

Basado en lo que se ha visto, ahora se puede empezar a entender lo que el intéprete Lisp hace cuando ejecutamos un comando para evaluar una lista. Primero, examina si hay un símbolo quote (cita) antes de la lista; si el intérprete da la lista. Por otro lado, si no hay cita, el intéprete mira si el primer elemento en la lista tiene una definición de función. De otro modo, el intéprete imprime un mensaje de error.

Así es como Lisp trabaja. Simple. Hay complicaciones añadidas que tendremos en un minuto, pero estas son fundamentales. De acuerdo, para escribir programas Lisp, se necesita conocer como escribir definiciones de función y adjuntarlas a nombres, y como hacer esto sin confundirnos a nosotros mismos o al ordenador.

Complicaciones   Variables, formas especiales, Listas.
1.5.1 Compilación de Bytes   Especialmente procesando código por la velocidad.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Complicaciones

Ahora, una primera complicación. Además de las listas, el intéprete Lisp puede evaluar un símbolo sin el símbolo cita (quote) y no tiene paréntesis alrededor. El intérprete Lisp intentará determinar el valor del símbolo como una variable. Esta situación está descrita en la sección acerca de variable. (Ver Variables.)

La segunda complicación ocurre debido a que algunas funciones son inusuales y no funcionan de la manera usual. Estas que no son llamadas formas especiales. Son usadas para trabajos especiales, como definir una función, y no son muchas de ellas. En los siguientes próximos capítulos, se introducirán varias de las formas especiales más importantes.

La tercera y final complicación es la siguiente: si la función que el intérprete Lisp está buscando no es una forma especial, y si eso es parte de una lista, el intérprete Lisp quiere ver si la lista tiene una lista dentro. Si hay una lista dentro, el intérprete Lisp primero mira qué hacer con la lista dentro, y entonces trabaja en la lista de fuera. Si todavía hay otra lista embebida dentro de la propia lista, eso funciona en esta primero, y así. Eso siempre funciona en la lista más interior. El intérprete funciona más interior primero, para evaluar el resultado de esta lista. El resultado puede ser usado por la expresión entre paréntesis.

De otra manera, el intérprete trabaja de izquierda a derecha, desde una expresión a la siguiente.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.5.1 Compilación de Bytes

Otro aspecto de interpretación: el intéprete Lisp es capaz de interpretar dos tipos de entidad: código humanemente legible, en el que focalizarse exclusivamente, y especialmente código procesado, llamado byte compilado, que no es humanamente legible. El código máquina compilado se ejecuta más rápido que el código humanamente legible.

Tu puedes transformar código legible por humanos dentro de código compilado ejecutando un de los comandos compilados tales como byte-compile-file. El código compilado es normamelte almacenado en un fichero que finaliza con una extensión ‘.elc’ en vez de una extensión ‘.el’. Verás ambos tipos de ficheros en el directorio ‘emacs/lisp’; los ficheros para leer estos son con extensiones ‘.el’.

Como una cuestión práctica, para la mayoría de las cosas tu podrías personalizar o extender Emacs, no necesitas compilar byte; y no discutirás el asunto aquí. Ver (elisp)Compilación de Byte sección `Compilación de Byte' en El Manual de Referencia de GNU Emacs, para una completa descripción de compilación byte.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.6 Evaluación

Cuando el intérprete Lisp funciona en una expresión, el término para la actividad es llamada evaluación. Decimos que el intérprete `evalúa la expresión'. Yo he usado este término varias veces antes. La palabra viene desde su uso en el lenguaje de cada día, `para cierto valor o cantidad de; para estimar' de acuerdo a Webster's New Collegiate Dictionary.

Cómo el Intérprete Actúa   Devolver y Efectos Colaterales...
1.6.1 Evaluando Listas Propias   Listas con listas...
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Cómo el Intérprete Actúa

Después de evaluar una expresión, el intérprete Lisp normalmente devuelve el valor que el ordenador produce trayendo las instrucciones encontradas en la definición de la función, o quizás dará esta función y producirá un mensaje de error. (El intérprete puede también quedarse colgado, así hablar, a una función diferente o puede intentar repetir continuamente que está haciendo para siempre y siempre en lo que está llamado como un `bucle infinito'. Estas acciones son menos comunes; y pueden ignorarse). Más frecuentemente, el intérprete devuelve un valor.

Al mismo tiempo el intérprete devuelve un valor, puede hacer cualquier cosa más también, tal como mover un cursor o copiar un fichero; este otro tipo de acción es llamada efecto lateral. Acciones que los humanos pensamos que son importantes tales como imprimir resultados son, con frecuencia, ``efectos laterales'' al intérprete Lisp. La jerga puede sonar peculiar, pero cambiar que es fácilmente fácil aprender a usar efectos laterales.

En resumen, evaluando una expresión simbólica normalmente causa que el intérprete devuelva un valor y quizás trajo un efecto lateral; o al menos produce un error.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.6.1 Evaluando Listas Propias

Si la evaluación se aplica a una lista que está dentro de una lista de fuera, se puede usar el valor devuelto por la primera evaluación como información cuando la lista de fuera está evaluada. Esto explica por qué las expresiones propias son evaluadas primero: los valores devueltos son usados por las expresiones de fuera.

Nosotros podemos investigar este proceso evaluando otro ejemplo adicional. Deja tu cursor después de la siguiente expresión y escribe C-x C-e:

 
(+ 2 (+ 3 3))

El número 8 aparecerá en el área echo.

Lo que ocurre es que el intérprete Lisp primero evalúa la expresión propia, (+ 3 3), para que el valor 6 se devuelva; entonces evalúa la expresión de fuera como si fuera escrita (+ 2 6), que devuelve el valor 8. Desde que no hay más expresiones cerradas para evaluar el intérprete imprime este valor en el área echo.

Ahora es fácil comprender el nombre de los comandos invocados por atajos C-x C-e: el nombre es eval-last-sexp. Las letras sexp son una abreviación para la `expresión simbólica', y eval es una abreviación para `evaluar'. El comando significa `evaluar la última expresión simbólica'.

Como un experimento, tu puedes intentar evaluar la expresión poniendo el cursor al principio de la siguiente línea inmediatamente siguiendo la expresión, o dentro de la expresión.

Aquí hay otra copia de la expresión:

 
(+ 2 (+ 3 3))

Si se posiciona el cursor al principio de la línea en blanco que inmediatamente sigue la expresión y escribes C-x C-e, todavía se obtendrá el valor 8 impreso en el área echo. Ahora intenta poner el cursor dentro de la expresión. Si se pone bien después del siguiente al último paréntesis (así aparece para situarse arriba del último paréntesis), ¡se obtendrá un 6 impreso en el área echo! Esto es porque el comando evalúa la expresión (+ 3 3).

Ahora se pone el cursor inmediatamente después de un número. Escribe C-x C-e y se tendrá el número en sí. En Lisp, si evalúas un número, tu tienes el número en sí---esto es cómo los números difiere desde los símbolos. Si evalúas una lista empezando con un símoblo como +, tendrás un valor devuelto que es el resultado del ordenador trayendo las instrucciones en la definición de función adjunta a este nombre. Si un símbolo por sí mismo es evaluado, alguna cosa diferente ocurre, como veremos en la siguiente sección.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.7 Variables

En Emacs Lisp, un símbolo puede tener un valor adjunto como puede tener una definición de función adjunta. Las dos son diferentes. La definición de función es un conjunto de instrucciones que un ordenador obedece. Un valor, por otro lado, es alguna cosa como un número o un nombre, que puede variar (que es porque tal símbolo es llamador una variable). El valor de un símbolo puede ser una expresión en Lisp, tal como un símbolo, número, lista, o cadena. Un símbolo que tiene un valor es con frecuencia llamado una variable.

Un símbolo puede tener ambos una definición de función y un valor adjunto al mismo tiempo. O puede tener solo uno u otro. Los dos están separados. Esto es algo similar al camino, el nombre Cambridge puede referirse a la ciudad en Massachusetts y tener alguna información adjunta al nombre tan bien, tal como ``gran centro de programación''.

Otro camino para pensar acerca de esto es imaginar un símbolo como ser una caja de cajones. La definición de función es poner en el cajón que maneja el valor que puede ser cambiado sin afectar los contenidos del cajón que maneja la definición de función, y viceversa.

• Ejemplo de fill-column  
1.7.1 Mensaje de Error para un Símbolo sin una Función   El mensaje de error para un símbolo sin una función.
1.7.2 Mensaje de Error para un Símbolo sin un Valor   El mensaje de error para un símbolo sin un valor.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

fill-column, un Ejemplo de Variable

La variable fill-column ilustra un símbolo con un valor adjunto: en cada buffer de GNU Emacs, este símbolo establece algún valor, normalmente 72 o 70, pero algunas veces algún otro valor. Para encontrar el valor de este símbolo, evalúalo por sí mismo. Si estás leyendo esto en Info dentro de GNU Emacs, tu puedes hacer esto poniendo el cursor después del símbolo y escribiendo C-x C-e:

 
fill-column

Después de que yo escribiera C-x C-e, Emacs imprimió el número 72 en mi área echo. Este es el valor por el que fill-column es escogido para mi, porque yo lo escribo. Puede ser diferente para ti en tu búffer Info. Sepa que el valor devuelto como una variable es impreso exactamente por el mismo camino que el valor devuelto por una función trayendo sus instrucciones. Desde el punto de vista del intérprete Lisp, un valor devuelto es un valor devuelto. El tipo de expresión viene desde ceder a la cuestión una vez el valor es conocido.

Un símbolo puede tener cualquier valor adjunto a ello o, usar la jerga, se puede bind (asociar) la variable a un valor: a un número, tal como 72; a una cadena, \"tal como esta\"; a una lista, tal como (spruce pine oak); podemos incluso asociar una variable a una definición de función.

Un símbolo puede ser emparejado por un valor en varios caminos. Ver Configurando el Valor de una Variable, para información acerca de un camino para hacer esto.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.7.1 Mensaje de Error para un Símbolo sin una Función

Cuando se evalúa fill-column para encontrar el valor de una variable, no se ponen paréntesis alrededor de la palabra. Esto es porque no pretendemos usarlos como un nombre de función.

Si fill-column fuese el primer o único elemento de una lista, el intérprete de Lisp intentaría encontrar la definición de función adjunta. Pero fill-column no tiene definición de función. Prueba evaluando esto:

 
(fill-column)

En GNU Emacs versión 22, se creará un ‘*Backtrace*’ buffer que dice:

 
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
  (fill-column)
  eval((fill-column))
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

(Recuerda, para salir del depurador y crear la ventana del depurador para ir fuera, escribe q en el ‘*Backtrace*’ buffer.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.7.2 Mensaje de Error para un Símbolo sin un Valor

Si intentas evaluar un símbolo que no tiene un valor asociado, recibirás un mensaje de error. Puedes ver esto experimentando con nuestra suma 2 más 2. En la siguiente expresión, pon tu cursor correcto después de +, antes del primer número 2, escribe C-x C-e:

 
(+ 2 2)

En GNU Emacs 22, se creará un buffer ‘*Backtrace*’ que dice:

 
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
  eval(+)
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

(Como con las otras veces nosotros introducimos el depurador, se puede salir escribiendo q en el búffer ‘*Backtrace*’.)

Esta traza es diferente desde los muy primeros mensajes de error que vimos, que dijimos, ‘El depurador introdujo--errores Lisp: (esta función está vacía)’. En este caso, la función no tiene una valor como una variable; mientras en el otro mensaje de error, la función (la palabra `this') no tuvo una definición.

Este experimento con el +, que nosotros hicimos fué causar que el intérprete para evalúe el + y buscar el valor de la variable en vez de la definición de la función. Nosotros hicimos esto dejando el cursor correcto después del símbolo en vez de después de los paréntesis que cierran la lista como hicimos antes. Como consecuencia, el intérprete Lisp evaluó la s-expresión precedente, que en este caso fué el + por sí mismo.

Desde que + no tiene un valor asociado, solo la definición de función, el mensaje de error reportado que el valor del símbolo como una variable estaba vacío.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.8 Argumentos

Para ver cómo la información pasa a funciones, se permite mirar de nuevo a nuestro viejo standby, la adición de dos más dos. En Lisp, esto es escrito como sigue:

 
(+ 2 2)

Si evalúas esta expresión, el número 4 aparecerá en tu área echo. Lo que el intérprete de Lisp hace es añadir los número que sigue el +.

Los números añadidos por + son llamados argumentos de la función +. Estos números son la información que es dada para o pasada a la función.

La palabra `argumento' viene del camino que es usado en matemáticas y no se refiere a una disputa entre 2 personas, sino que se refiere a la información presentada a la función, en este caso, al +. En Lisp, los argumentos a una función son los átomos o listas que siguen la función. Los valores devueltos por la evaluación de estos átomos o listas son pasados a la función. Funciones diferentes requieren diferentes números de argumentos; algunas funciones no requieren ninguno más.(2)

1.8.1 Tipos de Argumentos de Datos   Tipos de datos pasados a una función.
1.8.2 Un Argumento como el Valor de una Variable o Lista   Un argumento puede ser el valor de una variable o lista.
1.8.3 Número de Variables de Argumentos   Algunas funciones pueden tomar un número variable de argumentos.
1.8.4 Usando el Tipo Incorrecto de Objeto como un Argumento   Pasando un argumento del tipo incorrecto a una función.
1.8.5 La función message   Una función útil para enviar mensajes.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.8.1 Tipos de Argumentos de Datos

Los tipos de datos que deberían ser pasados a una función dependen de que tipo de información usan. Los argumentos a una función tales como + deben tener valores que son números, desde que + añade números. Otras funciones usan diferentes tipos de datos para sus argumentos.

Por ejemplo, la función concat enlaza o une dos o más cadenas de texto para producir una cadena. Los argumentos son cadenas. La concatenación de los dos caracteres de cadenas abc, def producen la cadena simple abcdef. Esto puede ser visto evaluando lo siguiente:

 
(concat "abc" "def")

El valor producido para evaluar esta expresión es "abcdef".

Una función tal como substring usa ambos una cadena y números como argumentos. La función devuelve una parte de la cadena, una subcadena del primer argumento. Esta función toma tres argumentos. Su primer argumento es la cadena de caracteres, el segundo y tercer argumento son números que indican el principio y fin de la subcadena. Los números son un contaje del número de caracteres (incluyendo espacios y puntuaciones) desde el principio de la cadena.

Por ejemplo, si evalúa lo siguiente:

 
(substring "The quick brown fox jumped." 16 19)

verá "fox" aparecer en el área echo. Los argumentos son la cadena y los dos números.

Nótese que la cadena pasada a subcadena es un átomo simple incluso aunque sea hecho de varias palabras separadas por espacios. Lisp cuenta cada cosa entre dos marcas de citas como parte de la cadena, incluyendo los espacios. Se puede pensar la función substring como una forma de `despedazar átomos' ya que toma un átomo indivisible y extrae una parte. Sin embargo, substring es solo capaz de extraer una subcadena desde un argumento que es una cadena, no otro tipo de átomo tal como un número o símbolo.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.8.2 Un Argumento como el Valor de una Variable o Lista

Un argumento puede ser un símbolo que devuelva un valor cuando es evaluado. Por ejemplo, cuando el símbolo fill-column por sí mismo es evaluado, devuelve un número. Este número puede ser usado en una adición.

Posicionar el cursor después la siguiente expresión y escribe C-x C-e:

 
(+ 2 fill-column)

El valor será un número dos más que tu tienes evaluando fill-column solo. Para mí, este es 74, porque mi valor de fill-column es 72.

Como nosotros hemos visto, un argumento puede ser un símbolo que devuelve una valor cuando es evaluado. Además, un argumento puede ser una lista que devuelve un valor cuando es evaluada. Por ejemplo, en la siguiente expresión, los argumentos para la función concat son las cadenas "The" y " red foxes." y la lista (number-to-string (+ 2 fill-column)).

 
(concat "The " (number-to-string (+ 2 fill-column)) " red foxes.")

Si evalúas esta expresión---y si, como con mi Emacs, fill-column evalúa a 72---"Los 74 zorros rojos." aparecerán en el área echo. (Nótese que deben ponerse espacio después de la palabra ‘The’ y antes de la palabra ‘red’ así aparecerán en la cadena final. La función number-to-string convierte los enteros que la función de adición devuelve una cadena. number-to-string es también conocida como int-to-string.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.8.3 Número de Variables de Argumentos

Algunas funciones, tales como concat, +, o *, toman cualquier número de argumentos. (El * es el símbolo para multiplicar.) Esto puede ser visto evaluando cada uno de las siguientes expresiones en el camino usual. Que verás en el área echo que está impresa en este texto después de ‘⇒’, que puedes leer como `evaluar a'.

En el primer conjunto, las funciones no tienen argumentos:

 
(+)       ⇒ 0

(*)       ⇒ 1

En este conjunto, las funciones tienen un argumento cada una:

 
(+ 3)     ⇒ 3

(* 3)     ⇒ 3

En este conjunto, las funciones tienen tres argumentos cada una:

 
(+ 3 4 5) ⇒ 12

(* 3 4 5) ⇒ 60
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.8.4 Usando el Tipo Incorrecto de Objeto como un Argumento

Cuando una función es pasada un argumento del tipo incorrecto, el interpréte Lisp produce un mensaje de error. Por ejemplo, la función + espera los valores de sus argumentos para ser números. Como un experimento nosotros podemos pasarlo el símbolo citado hello en vez de un número. Posicionar el cursor después la siguiente expresión y escribir C-x C-e:

 
(+ 2 'hello)

Cuando tu haces esto tu generarás un mensaje de error. Lo qué ha ocurrido es que + ha intentado añadir el 2 para el valor devuelto por 'hello, pero el valor devuelto por 'hello es el símbolo hello, no un número. Solo los números pueden ser añadidos. Así + podría no encarrilar su adición.

En GNU Emacs versión 22, se creará e introducirá un buffer ‘*Backtrace*’ que dice:

 
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error:
         (wrong-type-argument number-or-marker-p hello)
  +(2 hello)
  eval((+ 2 (quote hello)))
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Como es normal, el mensaje de error intenta ser útil y tiene sentido depués de que tu aprendas cómo leerlo.(3)

La primera parte del mensaje de error es honesto; dice ‘wrong type argument’ (mal tipo de argumento). Lo siguiente viene con la misteriosa palabra de jerga ‘number-or-marker-p’. Esta palabra está intentando contarte que tipo de argumento + esperabas.

El símbolo number-or-marker-p dice que el intérprete Lisp está intentando determinar si la información presentada (el valor del argumento) es un número o una marca (un objeto especial representando una posición de buffer). Lo que hace es testear para ver si el + está siendo números dados para añadir. También chequea para ver si el argumento es algo llamado un marcador, que es una funcionalidad específica de Emacs Lisp. (En Emacs, las localizaciones en un búffer son grabadas como marcadores. Cuando la marca está asignado con el atajo C-@ o C-<SPC>, su posición es guardado como un marcador. La marca puede ser considerada un número---el número de caracteres la localización está desde el principio del búffer.) En Emacs Lisp, + puede ser usado para añadir el valor numérico de posiciones de marca como números.

La ‘p’ de number-or-marker-p es el cuerpo de una práctica iniciada en los primeros días de la programación Lisp. La ‘p’ es para `predicado'. En la jerga usada por los primeros investigadores de Lisp, un predicado se refiere a una función para determinar si alguna propiedad es verdadera o falsa. Así la ‘p’ nos cuenta que number-or-marker-p es el nombre de una función que determina que el argumento dado es un número o una marca. Otros símbolos Lisp que finalizan en ‘p’ incluyen zerop, una función que chequea si sus argumentos tienen el valor de cero, y listp, una función que prueba si sus argumentos son una lista.

Finalmente, la última parte del mensaje de error es el símbolo hello. Esto es el valor del argumento que pasaba a +. Si la adición había sido pasada al tipo correcto de objeto, el valor pasado habría sido un número, tal como 37, en vez de un símbolo como hello. Pero entonces tu no habrías obtenido el mensaje de error.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.8.5 La función message

Como +, la función message toma un número variable de argumentos. Es usado para enviar mensajes para el usuario y es así tan útil que nosotros lo describiremos aquí.

Un mensaje está impreso en el área echo. Por ejemplo, se puede imprimir un mensaje en tu área echo evaluando la siguiente lista:

 
(message "¡Este mensaje aparece en el área echo!")

La cadena entera entre comillas dobles es un argumento simple y está impreso en toto. (Nótese que en este ejemplo, el mensaje en sí aparecerá en el área echo con comillas comillas dobles; que es porque tu ves el valor devuelto por la función message. En la mayoría de los usos de message en programas que se escribe, el texto será impreso en el área echo como un efecto lateral, sin las comillas. Ver multiply-by-seven en detalle, para un ejemplo de esto.)

Sin embargo, si hay un ‘%s’ en la cadena citada de caracteres, la función message no imprime el ‘%s’ como tal, pero mira al argumento que sigue la cadena. Eso evalúa el segundo argumento e imprime el valor en la posición en la cadena donde el ‘%s’ está.

Puedes ver esto posicionando el cursor después de la siguiente expresión y escribiendo C-x C-e:

 
(message "The name of this buffer is: %s." (buffer-name))

En Info, "El nombre de este búffer es: *info*." aparecerá en el área echo. La función buffer-name devuelve el nombre del búffer como una cadena, que la función message inserta en lugar de %s.

Para imprimir un valor como un entero, usa ‘%d’ en el mismo camino que ‘%s’. Por ejemplo, para imprimir un mensaje en el área echo que sitúa el valor de fill-column, evalúa lo siguiente:

 
(message "The value of fill-column is %d." fill-column)

En mi sistema, cuando evalúo esta lista, "El valor de fill-column es 72" aparece en mi área echo(4)

Si hay más de una ‘%s’ en la cadena citada, el valor del primer argumentos siguiente la cadena citada es impresa en la posición del primer ‘%s’ y el valor del segundo argunmento es impreso en la posición del segundo ‘%s’, y así.

Por ejemplo, si se evalúa lo siguiente,

 
(message "¡Hay %d %s en la oficina!"
         (- fill-column 14) "elefantes rosas")

un mensaje característico aparecerá en el área echo. En mi sistema dice "Hay 58 elefantes rosas en la oficina"

La expresión (- fill-column 14) está evaluado y el número resultante está insertado en lugar del ‘%d’; y la cadena entre dobles comillad, \"pink elephants\", está tratado como un argumento simple e insertado en lugar del ‘%s’. (Esto es decir, una cadena entre comillas dobres se evalúa así mismo, como un número.)

Finalmente, aquí está un ejemplo algo complejo que no solo ilustra la computación de un número, pero también muestra como se puede usar una expresión con una expresión para generar el texto que es sustituido por ‘%s’:

 
(message "He saw %d %s"
         (- fill-column 32)
         (concat "red "
                 (substring
                  "The quick brown foxes jumped." 16 21)
                 " leaping."))

En este ejemplo, message tiene tres argumentos: la cadena, "El ve %d %s", la expresión, empieza con la función concat. El valor resultante desde la evaluación de (- fill-column 32) está insertado en lugar de ‘%d’; y el valor devuelto por la expresión empieza con concat está insertado en lugar del ‘%s’.

Cuando se rellena la columna es 70 y se evalúa la expresión, el mensaje "Se vieron 38 zorros rojos trotando." aparece en tu área echo.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.9 Configurando el Valor de una Variable

Hay varios caminos por el que una variable puede dar un valor. Uno de los caminos es usar la función set o la función setq. Otro caminos es usar let (véase la sección let). (La jerga para este proceso es bind una variable para un valor.)

Las siguientes secciones no solo describen cómo set y setq funcionan pero también ilustran como los argumentos pasan.

1.9.1 Usando set   Configurando valores.
1.9.2 Usando setq   Configurando un valor citado.
1.9.3 Contando   Usando setq para contar.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.9.1 Usando set

Para asignar el valor del símbolo flowers a la lista '(rose violet daisy buttercup), evalúa la siguiente expresión posicionando el cursor después de la expresión y escribiendo C-x C-e.

 
(set 'flowers '(rose violet daisy buttercup))

La lista (rose violet daisy buttercup) aparecerá en el área echo. Esto es lo que está devuelto por la función set. Como efecto lateral, el símbbolo flowers está asociado a la lista; esto es, el símbolo flowers, que puede ser visto como una variable, es dado por la lista como su valor. (Este proceso, por el camino, ilustra cómo un efecto lateral al intérprete Lisp, asignando el valor, puede ser el efecto primario que nosotros humanos estamos interesados. Esto es porque cada función Lisp debe devolver un valor si no se obtiene un error, pero solo tendrá un efecto lateral si eso está diseñado para tener uno.)

Después de evaluar la expresión set, se puede evaluar el símbolo flowers y devolverá el valor asignado. Aquí está el símbolo. Emplaza tu cursor después y escribe C-x C-e.

 
flowers

Cuando se evalúa flowers, la lista (rose violet daisy buttercup) aparece en el área echo.

Incidentalmente, si evalúas 'flowers, la variable con una comilla en frente, lo que verás en el área echo es el símbolo en sí, flowers. Aquí está el símbolo citado, así tu puedes probar esto:

 
'flowers

Nótese también, que cuando se usa set, se necesita citar ambos argumentos a set, a menos que tu quieras evaluarlo. Desde que nosotros no queremos argumentos evaluados, nunca la variable flowers no la lista (rose violet daisy buttercup), ambos son citados. (Cuando tu usas set sin citar su primer argumento, el primer argumentos es evaluado antes que cualquier cosa sea hecha. Si tu hiciste esto y flowers no tenía un valor ya, tu tendrías un mensaje de error que el ‘Valor de símobolo como variable esté vacío’; por otro lado, si flowers no devolvió un valor después de que fuera evaluado, el set intentaría establecer un valor después de que fuera devuelto. Hay situaciones donde esto es lo correcto para la función a hacer, pero tales situaciones son raras.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.9.2 Usando setq

Como materia práctica, casi siempre se cita el primer argumento a set. La combinación de set y un argumento citado primero es común que tiene su propio nombre: la forma especial setq. Esta forma especial es solo como set excepto que el primer argumento es citado automáticamente, así no necesitas escribir la marca de cita por tí mismo. También, como una conveniencia añadida, setq permite asignar varias variables diferentes a diferentes valores, todo en una expresión.

Para asginar el valor de la variable carnivores a la lista '(lion tiger leopar) usando setq, la siguiente expresión es usada:

 
(setq carnivores '(lion tiger leopard))

Esto es exactamente lo mismo que usar set excepto que el primer argumento es automáticamente citado por setq. (El ‘q’ en setq significa quote.)

Con set, la expresión se vería como esta:

 
(set 'carnivores '(lion tiger leopard))

También, setq puede ser usado para asignar diferentes valores a diferentes variables. El primer argumento está asociado al valor del segundo argumento, el tercer argumento se asocia al valor del cuarto argumento, y así. Por ejemplo, se podría usar el lo siguiente para asignar una lista de árboles al símbolo trees y una lista herbívoros al símbolo herbivores:

 
(setq trees '(pine fir oak maple)
      herbivores '(gazelle antelope zebra))

(La expresión podría también haber estado en una línea, pero podría no haberse ajustado en una página; y los humanos encuentran eso fácil de leer bien listas formateadas.)

Aunque yo he estado usando el término `assign', hay otro camino de pensar acerca de los trabajos de set y setq; y que es decir que set y setq creen el símbolo point a la lista. Este camino posterior de pensamiento es muy común y en los capítulos siguientes volveremos al menos a un símbolo que tiene un valor, específicamente una lista, adjunta; o, expresado otro caminos, el símbolo asigna a ``apuntar'' a la lista.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.9.3 Contando

Aquí hay un ejemplo que muestra cómo usar setq en un contador. Se podría usar esto para contar cuantas veces una parte de tu programa repite por sí mismo. Primero asigna una variable a cero; entonces añade uno al número cada vez que el programa se repite así mismo. Para hacer esto, se necesita una variable que sirve como un contador, y dos expresiones: una expresión setq que asigna la variable contador a cero; y una segunda expresión setq que incrementa el contador cada vez que eso es evaluado.

 
(setq counter 0)                ; Let's call this the initializer.

(setq counter (+ counter 1))    ; This is the incrementer.

counter                         ; This is the counter.

(El siguiente texto el ‘;’ son comentarios. Ver @xref{Cambiar una Definici@'on de Funci@'on, , Cambiar una Definici@'on de Funci@'on}.)

Si evalúas la primera de estas expresiones, el inicializador, (setq counter 0), y entonces evalúa la tercera expresión, counter, el número 0 aparecerá en el área echo. Si entonces se evalúa la segunda expresión, el incrementador, (setq counter (+ counter 1)), el contador obtendrá el valor 1. Así si evalúas de nuevo counter, el número 1 aparecerá en el área echo. Cada vez que se evalúa la segunda expresión, el valor del contador será incrementado.

Cuando se evalúa el incrementador, (setq counter (+ counter 1)), el intérprete Lisp primero evalúa la lista interna; esta es la adición. En orden para evaluar esta lista, debe evaluar la variable counter y el número 1. Cuando evalúa la variable counter, recibe su valor actual. Esto pasa su valor y el número 1 para el + que los añade juntos. La suma es devuelta como el valor de la list propia pasada al setq que asigna la variable counter a este nuevo valor. De este modo, el valor de la variable counter, es cambiado.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.10 Resumen

Aprender Lisp es como escalar una montaña en la que la primera parte es la empinada. Ahora has escalado la parte más difícil; y lo que queda es más fácil.

En resumen,

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

1.11 Ejercicios

Unos pocos ejercicios simples:

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

2. Practicando Evaluación

Antes de aprender como escribir una definición de función en Emacs Lisp, es útil gastar un poco de tiempo evaluando varias expresiones que ya han sido escritas. Estas expresiones serán listas con las funciones como su primer (y con frecuencia único) elemento. Desde alguna de las funciones asociadas con búffers son ambas simples e interesantes, nosotros empezaremos con estas. En esta sección, evaluaremos unas pocas de estas. En otra sección, estudiaremos el código de varios otros funciones relacionadas con búffers, para ver cómo fueron escritas.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]
Cómo Evaluar  
Escribiendo comandos de edición o C-x

C-e causa evaluación. 2.1 Nombres de Buffer  Buffers y ficheros son diferentes. 2.2 Obteniendo Buffers  Obteniendo un buffer por sí mismo, no solamente su nombre. 2.3 Cambiando Buffers  Cómo cambiar a otro buffer. 2.4 Tamaño de Buffer y la Localización del Punto  Dónde el punto está localizado y el tamaño del buffer. 2.5 Ejercicio 

@end menu

Cómo Evaluar

Siempre y cuando se de un comando de edición a Emacs Lisp, tal como el comando para mover el cursor o el scroll de la pantalla, se está evaluando una expresión, el primer elemento del que es una función. Esto es cómo Emacs funciona.

Cuando se escriben teclas, se causa que el intérprete Lisp evalúe una expresión que devuelve resultados. Incluso escribiendo texto plano se evalúa la función Emacs Lisp, en este caso, uno que usa self-insert-command, simplemente inserta el caracter que tu escribiste. Las funciones que se evalúan escribiendo atajos de teclado son llamadas funciones interactive, o commands; como crear una fución interactive será ilustrada en el capítulo sobre cómo escribir definiciones de funciones. Ver Creando una Función Interactive.

Además de escribir comandos de teclado, hemos visto un segundo camino para evaluar una expresión: posicionar el cursor después de una lista y escribiendo C-x C-e. Esto es lo que nosotros haremos en el resto de esta sección. Hay otros caminos de evaluar una expresión también; que serán descritos como vienen.

Siendo usadas para evaluación práctica, las funciones mostradas en las siguientes pocas secciones son importantes en su propio derecho. Un estudio de estas funciones hace clara la distinción entre búffers y ficheros, cómo cambiar a un búffer, y como determinar una localización con ella.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

2.1 Nombres de Buffer

Las dos funciones, buffer-name y buffer-file-name, muestra la diferencia entre un fichero y un búffer. Cuando se evalúa la siguiente expresión, (buffer-file-name), el nombre del fichero para el que el búffer se refiere aparece en el área echo. Normalmente, el nombre devuelto por (buffer-name) es lo mismo que el nombre del fichero para el que se refiere, y el nombre devuelto por (buffer-file-name) es la ruta completa del fichero.

Un fichero y un búffer son dos entidades diferentes. Un fichero es información grabada de manera permanente en el ordenador (a menos que tu lo borres). Un búffer, por otro lado, es información dentro de Emacs que evanecerá al final de la sesión de la edición (o cuando mates el búffer). Normalmente, un búffer contiene información que has copiado desde un fichero; nosotros decimos que el búffer está visitando este fichero. Esta copia es la que se trabaja y modifica. Los cambios al búffer no cambian el fichero, hasta ser guardados. Cuando se guarda el búffer, el búffer está copiado al fichero y está de este modo salvado de manera permanente.

Si estás leyendo esto en Info dentro de GNU Emacs, se puede evaluar cada una de las siguientes expresiones posicionando el cursor después de eso y escribiendo C-x C-e.

 
(buffer-name)

(buffer-file-name)

Cuando hago esto en Info, el valor devuelto para la evaluación de (buffer-name) es ‘"*info"’, y el valor devuelto por evaluar (buffer-file-name) es ‘nil’.

Por otro lado, mientras se está escribiendo este documento, el valor devuelto por la evaluación de (buffer-name) es ‘"introduction.texinfo"’, y el valor devuelto por la evaluación (buffer-file-name) es ‘"/gnu/work/intro/introduction.texinfo"’.

La forma es el nombre del búffer y lo posterior es el nombre del fichero. En Info, el nombre búffer es ‘"*info*"’. Info no apunta a cualquier fichero, así el resultado de evaluar (buffer-file-name)] es ‘nil’. El símbolo nil es desde la palabra latina para `nada'; en este caso, significa que el búffer no está asociado con cualquier fichero. (En Lisp, nil también se usa con el significado de `falso' y es sinómino de la lista vacía, ().)

Cuando estoy escribiendo, el nombre de mi búffer es ‘"introduction.texinfo"’. El nombre del fichero al que se apunta es ‘"/gnu/work/intro/introduction.texinfo"’.

(En las expresiones, los paréntesis hacen que el intérprete Lisp trate a buffer-name y buffer-file-name como funciones; sin los paréntesis, el intérprete intentaría evaluar los símbolos como variables. Ver Variables.)

A pesar de la distinción entre ficheros y buffers, con frecuencia se encuentra que hay personas que se refieren a un fichero cuando quieren un búffer y al revés. En realidad, la mayoría de las personas dicen, ``Yo estoy editando un fichero,'' en vez de decir, ``Estoy editando un búfer que pronto se guardará en un fichero.'' Es casi siempre claro desde el contexto que las personas quieren decir. Al tratar con programas de ordenador, sin embargo, es importante tener la distinción en mente, ya que el ordenador no es una persona inteligente.

La palabra `búffer', por el camino, viene desde el significado de la palabra como una cuña que mata la fuerza de una colisión. En los primeros ordenadores, un búffer acuñaba la interacción entre ficheros y la unidad de procesamiento central. Los tambores o cintas que manejan un fichero y la unidad de procesamiento central fueron piezas de equipamiento que fueron muy diferentes desde que cualquier otro, trabajaba en sus propias velocidades. El búffer se hizo posible para ellos a trabajar juntos de manera efectiva. Finalmente, el búffer creció siendo uno intermedio, un lugar tomado temporalmente, para ser el lugar donde el trabajo está hecho. Esta transformación es como un pequeño puerto de mar que crece dentro de una gran ciudad: una vez fué el lugar donde el lugar donde la carga era depositada temporalmente antes de ser cargada dentro de los barcos; entonces eso llega a ser un negocio y centro cultural en su propio derecho.

No todos los búffers están asociados con ficheros. Por ejemplo, un búffer no visita cualquier fichero. De manera similar, un búffer ‘*Help*’ no está asociado con cualquier fichero.

Antaño, cuando se perdía un fichero ‘~/.emacs’ y se empezaba una sesión Emacs escribiendo el comando emacs solo, sin nombrar ficheros Emacs iniciaba con el búffer ‘*scratch*’ visible. En estos días, se ve una página de inicio. Se puede seguir uno de los comandos sugeridos en dicha pantalla, visitar un fichero, o presionar la barra espaciadora para lograr el búffer ‘*scratch*’.

Si se cambia al búffer ‘*scratch*’, se escribe la posición del (buffer-name) del cursor después, y entonces escribe C-x C-e para evaluar la expresión. El nombre *scratch* será devuelto y aparecerá en el área echo. *scratch* es el nombre del búffer. Cuando escribes (buffer-file-name) en el búffer ‘*scratch*’ y evalúa que, nil aparecerá en el área echo, solo se hace cuando evalúas (buffer-file-name) en Info.

Incidentalmente, si estás en el búffer ‘*scratch*’ y quiere el valor devuelto por una expresión para aparecer en el búffer por sí mismo que en el área echo, escribe C-u C-x C-e en vez de C-x C-e. Esto causa el valor devuelto para aparecer después de la expresión. El búffer se verá así:

 
(buffer-name)"*scratch*"

No se puede hacer esto en Info desde que Info es de solo lectura y no se permitirá que se cambien los contenidos en el búffer. Pero puedes hacer esto en cualquier búffer que se puede editar; y cuando se escribe código de documentación (tal como este libro), esta funcionalidad es muy útil.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

2.2 Obteniendo Buffers

La función buffer-name devuelve el name del búffer; para obtener el búffer en sí, una función diferente es necesaria: la función current-buffer. Si usa esta función en el código, que tiene en el búffer en sí.

Un nombre y el objeto o entidad para el que el nombre se refiere son cosas diferentes. Tu no eres tu nombre, Tu eres una persona que otras personas se refieren por tu nombre. Si preguntas para hablar por Jorge y alguien escribe una carta con las letras ‘J’, ‘o’, ‘r’, ‘g’, y ‘e’ escrito, tu podrías estar distraido, pero no estarías satisfecho. No quieres hablar al nombre, pero sí a la persona a la que el nombre se refiere. Un búffer es similar: el nombre del búffer scratch es ‘*scratch*’, pero el nombre no es el búffer. Para tener un búffer por sí mismo, se necesita usar una función tal como current-buffer.

Sin embargo, hay una ligera complicación: si evalúas current-buffer en una expresión por sí mismo, como haremos aquí, lo que ves es una representación impresa del nombre del búffer sin los contenidos del búffer. Emacs funciona en este camino por dos razones: el búffer puede contener miles de líneas---eso es demasiado largo para ser convenientemente mostrado; y, otro búffer puede tener los mismos contenidos pero un nombre diferente, y es importante distinguirlo.

Aquí hay una expresión conteniendo la función:

 
(current-buffer)

Si se evalúa esta expresión de Info en Emacs en el camino normal, ‘#<buffer *info*>’ aparecerá en el área echo. El formato especial indica que el búffer por sí mismo está siendo devuelto, en vez de solo su nombre.

Incidentalmente, mientras se escribe un número o símbolo en un programa, no se puede hacer esto con la representación impresa del búffer: el único camino para tener un búffer por sí mismo es con una función tal como current-buffer.

Un función relacionada es other-buffer. Esto devuelve los buffers seleccionados más recientemente que los únicos en los que tu estás actualmente, no una representación impresa de su nombre. Si tu recientemente has cambiado fuera de ‘*scratch*’ búffer, other-buffer devolverá este búffer.

Puedes ver esto evaluando la expresión:

 
(other-buffer)

Verás que ‘#<buffer *scratch*>’ aparece en el área echo, o el nombre de cualquier otro búffer que se cambió recientemente(5)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

2.3 Cambiando Buffers

La función other-buffer actualmente proporciona un búffer cuando es usada como un argumento a una función que uno requiere. Podemos ver esto usando other-buffer y switch-to-buffer para cambiar al búffer diferente.

Pero primero, una breve introducción a la función switch-to-buffer. Cuando tu cambias atrás y adelante desde Info al búffer para evaluar (buffer-name), normalmente se escribe C-x b y se visualiza ‘*scratch*’(6) cuando se ve en el minibuffer el nombre del búffer al que tu quieres cambiar. El atajo, C-x b, causa que el intérprete Lisp evalúe la función interactiva switch-to-buffer. Como nosotros dijimos antes, esto es como Emacs funciona: diferentes atajos de teclado llaman o ejecutan diferentes funciones. Por ejemplo, C-f llama forward-char, M-e llama a forward-sentence y así

Escribiendo switch-to-buffer en una expresión, y dándole un búffer para cambiar, podemos cambiar a buffers solo el camino C-x b hace.

Aquí está la expresión Lisp:

 
(switch-to-buffer (other-buffer))

El símbolo switch-to-buffer es el primer elemento de la lista, así el intérprete Lisp tratará eso como una función y trae las instrucciones adjuntas a eso. Pero antes de hacer esto, el intérprete notará este other-buffer está dentro de paréntesis y trabaja en este símbolo primero. other-buffer es el primero (y en este caso, el único) elemento de esta lista, así el intérprete Lisp llama o ejecuta la función. Eso devuelve otro búffer. Después, el intérprete ejecuta switch-to-buffer, pasando, como un argumento, el otro búffer, que es al que Emacs cambia. Si estás leyendo esto en Info, prueba esto ahora. Evalúa la expresión. (Para volver, escribe C-x b <RET>.)(7)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

2.4 Tamaño de Buffer y la Localización del Punto

Finalmente, permítame en varias funciones simples, buffer-size, point, point-min, y point-max. Estas dan información acerca del tamaño de un búffer y la localización del punto con eso.

La función buffer-size te cuenta el tamaño del búffer actual; que es, la función un contaje del número de caracteres en el buffer.

 
(buffer-size)

Puedes evaluar esto en el camino usual, posicionando el cursor después de la expresión y escribiendo C-x C-e.

En Emacs, la posición actual del cursor es llamada punto. La expresión (punto) devuelve un número que cuenta donde está localizado como un contaje del número de caracteres desde el principio del búffer al punto.

Se puede ver el contaje de caracteres apuntar en este búffer evaluando la siguiente expresión en el camino normal:

 
(point)

Mientras escribo esto, el valor de point es 65724. La función point está frecuentemente usada en alguno de los ejemplos posteriores en este libro.

El valor del punto depende, de acuerdo, a la posición que tiene en el búffer. Si evalúas punto en este lugar, el número será largo:

 
(point)

Para mí, el valor del punto en esta posición es 66043, que significa que hay 319 caracteres (incluyendo espacios) entre las dos expresiones. (Sin duda, verás diferentes números, puesto que he editado esto desde que evaluó point.)

La función point-min es similar a point, pero eso devuelve del valor mínimo permisible del punto en el búffer actual. Este es el número 1 a menos que narrowing esté en efecto. (Narrowing, Encogiendo es un mecanismo donde uno se puede encoger a uno mismo, o un programa, a operaciones en solo un parte de un búffer. Extendiendo y Encogiendo.) Así, la función point-max devuelve el valor del valor máximo permisible del punto en el búffer actual.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

2.5 Ejercicio

Encuentra un fichero con que tu estás trabajando y mueve hasta la mitad. Encuentra el nombre de búffer, el nombre del fichero, tamaño, y su posición en el fichero.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3. Cómo Escribir Definiciones de Funciones

Cuando el intérprete evalúa una lista, parece ver si el primer símbolo en la lista tiene definición adjunta; o, poner otro camino, si el símbolo apunta a una definición de función. Si lo hace, el ordenador trae las instrucciones en la definición. Un símbolo que tiene una definición de función llamada, simplemente, una función (aunque apropiadamente hablando, la definición es la función y el símbolo se refiere a eso).

Una Vía acerca de Funciones Primitivas  
3.1 La Forma Especial defun   La forma especial defun.
3.2 Instalar una Definición de Función   Instalar una definición de función.
3.3 Crear una Función Interactive   Creando una función interactive.
3.4 Opciones Diferentes para interactive   Opciones diferente para interactive.
3.5 Instalar Código Permanentemente   Instalando código permanentemente.
3.6 let   Creando e inicializando variables locales.
3.7 La Forma Especial if   ¿Y qué si?
3.8 Expresiones If–then–else   Expresiones If--then--else.
3.9 Verdad y Falsedad en Emacs Lisp   Que considera Lisp verdad y falsedad.
3.10 save-excursion   Guardando la traza del punto, la marca, y el buffer.
3.11 Revisar  
3.12 Ejercicios  
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Una Vía acerca de Funciones Primitivas

Todas las funciones están definidas en términos de otras funciones, excepto por unas funciones primitivas que son escritas en el lenguaje de programación C. Cuando se escriben definiciones de funciones, se escriben en Emacs Lisp y se usan otras funciones como bloques en construcción. Alguna de las funciones usadas en sí mismas están escritas en Emacs Lisp (quizás por tí) y algunas serán primitivas escritas en C. Las funciones primitivas están escritas en C así podemos fácilmente ejecutarlas en GNU Emacs en cualquier ordenador que tiene suficiente poder y puede ejecutar C.

Permíteme enfatizar esto: cuando se escribe código en Emacs Lisp, no se distinge entre el uso de funciones escritas en C y el uso de funciones escritas en Emacs Lisp. La diferencia es irrevelante. Yo menciono la distinción solo porque es interesante conocerla. A menos que se investigue, uno no se da cuenta si una función ya escrita es escrita en Emacs Lisp o C.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.1 La Forma Especial defun

En Lisp, un símbolo tal como mark-whole-buffer tiene código adjunto que cuenta lo que el ordenador hace cuando la función es llamada. Este código es llamado la definición de función y es creado evaluando una expresión Lisp que empieza con el símbolo defun (que es una abreviación para función define). Porque defun no evalúa sus argumentos en el camino usual, eso se llama forma especial.

En secciones subsiguientes, miraremos en definiciones de función desde el código fuente Emacs, tales como mark-whole-buffer. En esta sección, describiremos una definición de función simple, así puedes ver como se ve. Esta definición de función usa aritmética porque es un ejemplo simple. Algunas personas no le gustan los ejemplos usando aritmética; sin embargo, si usted es tal persona, no se asuste. En realidad, cualquier código que se puede estudiar en esta introducción va a recordar a aritmética o matemáticas. Los ejemplos de manera mayoritaria involucran texto en un camino u otro.

Una definición de función tiene cinco partes siguiendo la palabra defun:

  1. El nombre del símbolo para el que la definición de función sería adjunta.
  2. Una lista de los argumentos que serán pasados a la función. Si no hay argumentos, tendremos una lista vacía, ().
  3. Documentación describiendo la función. (Técnicamente opcional, pero fuertemente recomendada.)
  4. Opcionalmente, una expresión para crear la función interactive así se puede usar escribiendo M-x y entonces el nombre de la función; o escribiendo una tecla apropiada o acorde.
  5. El código que instruye el ordenador qué hacer: el cuerpo de la definición de función.

Es útil pensar las cinco partes de una definición de función siendo organizada en una plantilla, con slots para cada parte:

 
(defun function-name (arguments…)
  "optional-documentation…"
  (interactive argument-passing-info)     ; optional
  body…)

Por ejemplo, aquí está el código para una función que multiplica sus argumentos por 7. (Este ejemplo no es interactivo. Ver Creando una Función Interactive, para esta información.)

 
(defun multiply-by-seven (number)
  "Multiply NUMBER by seven."
  (* 7 number))

Esta definición empieza con un paréntesis y el símbolo defun seguido por el nombre de la función.

El nombre de la función está seguido por una lista que contiene los argumentos que serán pasados a la función. Esta lista es llamada por la lista de argumentos. En este ejemplo, la lista tiene solo un elemento, el símbolo número. Cuando la función es usada, el símbolo será asociado al valor que es usado como el argumento para la función

En vez de elegir la palabra número por el nombre del argumento, podría haber escogido cualquier otro nombre. Por ejemplo, podría haber elegido la palabra multiplicando. Yo escojo la palabra `número' porque cuenta qué tipo de valor se pretende para este slot; pero yo podría haber elegido `multiplicando' para indicar el rol que el valor emplaza en este slot jugará en los trabajos de la función. Yo podría haber llamado foogle, pero habría sido una mala elección porque no contaría qué significa. La elección del nombre es subir al programador y habría elegido crear el significado claro de la función.

En realidad, se puede elegir cualquier nombre que se desee para un símbolo en una lista de argumentos, incluso el nombre del símbolo usado en alguna otra función: el nombre a usar en una lista de argumentos es privado para esta definición particular. En esta definición, el nombre se refiere a una entidad diferente que cualquiera que usa el mismo nombre fuera de la definición de función. Supón que tienes un apodo `corto' en tu familia; cuando tus miembros de familia se refieren a `corto', significa el apodo. Pero fuera de tu familia, en una película, por ejemplo, el nombre `corto' se refiere a alguien más. Porque un nombre en una lista de argumentos es privado para la definición de la función, se puede cambiar el valor de un símbolo dentro del cuerpo de una función sin cambiar su valor fuera de la función. El efecto es similar a este producido por una expresión let. (Ver sección let.)

La lista de argumentos está seguida por la documentación que describe la función. Esto es lo que tu ves cuando tu escribes C-h f y el nombre de una función. Incidentalmente, cuando se escribe una documentación como esta, se haría la primera línea una frase completa desde algunos comandos, tal como apropos, imprime solo la primera línea de una documentación multi-línea. También, no indentaría la segunda línea de una documentación, si tu tienes una, esto se ve cuando usas C-h f (describe-function). La documentación es opcional, pero es también útil, debería ser incluido en casi cualquier función que se escribe.

La tercera línea del ejemplo consiste en el cuerpo de la definición de función. (La mayoría de las definiciones de funciones, de acuerdo, son más largas que esto.) En esta función, el cuerpo es la lista, (* 7 number), que dice multiplicar el valor de número por 7. (En Emacs Lisp, * es la función para la multiplicación, solo como + es la función de suma.

Cuando se usa la función multiply-by-seven, el argumento number evalúa para el número actual que quiere ser usada. Aquí hay un ejemplo que muestra como multiply-by-seven es usada; pero ¡no intentes evaluar esto primero!.

 
(multiply-by-seven 3)

El símbolo número, especificado en la definición de función en la siguiente sección, es dada o ``emparejado a'' el valor 3 en el uso actual de la función. Note que aunque número estaba dentro de paréntesis en la definición de función, el argumento pasado a la función multiply-by-seven no está entre paréntesis. Los paréntesis son escritos en la definición de función así el ordenador puede figurarse donde la lista de argumentos finaliza y el resto de la definición de función empieza.

Si se evalúa este ejemplo, se obtendrá un mensaje error. (Ve adelante, pruébalo) Esto es porque hemos escrito la definición de función pero no le hemos contado todavía al ordenador la definición --- no se ha instalado (o `cargado') la definición de función en Emacs. Instalando una función es el proceso que cuenta al intérprete Lisp la definición de la función. La instalación es descrita en la siguiente sección.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.2 Instalar una Definición de Función

Si estás leyendo esto dentro de Info en Emacs, se puede probar la función multiply-by-seven evaluando primero la definición de función y entonces evaluando (multiply-by-seven 3). Una copia de la definición sigue. Emplaza el cursor después del último paréntesis de la definición de función y escribe C-x C-e. Cuando se hace esto, multiply-by-seven aparecerá en el área echo. (Lo que significa es que cuando una definición de función es evaluada, el valor devuelto es el nombre de la función definida.) Al mismo tiempo, esta acción instala la definición de función.

 
(defun multiply-by-seven (number)
  "Multiply NUMBER by seven."
  (* 7 number))

Evaluando esta defun, se ha instalado multiply-by-seven en Emacs. La función es ahora solo una parte de Emacs como forward-word o cualquier otra editando la función que se usa. (multiply-by-seven estará instalada hasta que sales de Emacs. Para recargar código automáticamente siempre y cuando empieces Emacs, ver @ref{Instalar C@'odigo Permanentemente, , Instalar C@'odigo Permanentemente}.)

El efecto de instalación  
3.2.1 Cambiar una Definición de Función   Cómo cambiar una definición de función
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

El efecto de instalación

Se puede ver el efecto de instalar multiply-by-seven evaluando el siguiente ejemplo. Localiza el cursor después de la siguiente expresión y escribe C-x C-e. El número 21 aparacerá en el área echo.

 
(multiply-by-seven 3)

Si lo deseas, se puede leer la documentación para la función escribiendo C-h f (describe-function) y entonces el nombre de la función, multiply-by-seven. Cuando haces esto, una ventana ‘*Help*’ aparecerá en tu pantalla que dice:

 
multiply-by-seven es una función Lisp.
(multiply-by-seven NUMBER)

Multiplicar NUMERO por siete.\n

(Para devolver a una ventana simple en tu pantalla, escribe C-x 1.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.2.1 Cambiar una Definición de Función

Si quieres cambiar a cambiar el código en multiply-by-seven, solo reescríbelo. Para instalar la nueva versión en lugar de la vieja, evalúa la definición de la función de nuevo. Así se cómo modifica el código en Emacs. Es muy simple,

Por ejemplo, se puede cambiar la función multiply-by-seven añade el número por sí mismo siete veces en vez de multiplicar el número por siete. Eso produce la misma respuesta, pero por una ruta diferente. Al mismo tiempo, añadiremos un comentario; un comentario es texto que el intérprete Lisp ignora, pero un lector humano puede encontrar útil o iluminante. El comentario es que esto es la ``segunda versión''.

 
(defun multiply-by-seven (number)       ; Second version.
  "Multiplicar NUMERO por siete."
  (+ number number number number number number number))

El comentario sigue por un punto y coma, ‘;’. En Lisp cada cosa en una línea sigue un punto y coma que es un comentario. El final de la línea es el fin del comentario. Para estrecar un comentario a través de dos o más líneas, empieza cada línea con un punto y coma.

@xref{Empezando con Fichero @file{.emacs}, , Empezando un Fichero @file{.emacs}}, y (elisp)Comentarios sección `Comentarios' en El Manual de Referencia de GNU Emacs Lisp, para más comentarios.

Se puede instalar esta versión de la función multiply-by-seven para evaluándolo en el mismo camino que se evaluó la primera función: deja el cursor después de los últimos paréntesis y escribe @kdb{C-x C-e}.

En resumen, esto es cómo se escribe código en Emacs Lisp: tu escribes una función; se instala; se testea; y entonces crea arreglos y mejoras e instálalas de nuevo.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.3 Crear una Función Interactive

Se crea una función interactive emplazando una lista que empieza con la forma especial interactive inmediatamente después de la documentación. Un usuario puede invocar una función interactive escribiendo @kdb{M-x} y entonces el nombre de la función; o escribiendo las teclas para el que está emparejado, por ejemplo, escribiendo C-n para next-line o C-x h para mark-whole-buffer.

De manera interesante, cuando se llama a una función interactive interactivamente, el valor devuelto no está automáticamente mostrado en el área echo. Esto es porque con frecuencia se llama a una función interactive para sus efectos laterales, tales como moviendo hacia adelante por una palabra o línea, y no para el valor devuelto. Si el valor devuelto fuera mostrado en el área echo cada vez que escribiste una tecla, distraería mucho

Un multiply-by-seven interactive, Un Resumen   Un resumen
3.3.1 Un multiply-by-seven Interactivo   La versión interactive.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Un multiply-by-seven interactive, Un Resumen

Ambos el uso de la forma especial interactive y un camino para mostrar un valor en el área echo puede ser ilustrada creando una versión interactiva de multiply-by-seven.

Aquí está el código:

 
(defun multiply-by-seven (number)       ; Versión Interactiva.
  "Multiplicar NUMERO por siete."
  (interactive "p")
  (message "The result is %d" (* 7 number)))

Se puede instalar este código emplazando tu cursor después y escribiendo @kdb{C-x C-e}. El nombre de la función aparecerá en tu área echo. Entonces, se puede usar este código escribiendo C-u y un número y entonces escribiendo M-x multiply-by-seven y presionando <RET>. La frase ‘El resultado es …’ seguido por el producto aparecerá en el área echo

Hablando más generalmente, invoca una función como esta dentro si de dos caminos:

  1. Escribiendo un argumento prefijo que contienes el número para ser pasado, y entonces escribiendo M-x y el nombre de la función, como con @kdb{C-u 3 M-x forward-sentence}; o,
  2. Escribe siempre la tecla/s de la función estén emparejadas, como con @kdb{C-u 3 M-e}.

Ambos ejemplos solo trabajan mencionados idénticamente para mover puntos hacia adelantes tres frases. (Desde multiply-by-seven no está emparejado a una techa, eso no podría ser usado como un ejemplo de emparejar la tecla.

(@xref{Atajos de teclas, , Algunos Atajos de Teclas}, para aprender como emparejar un comando a una tecla.)

Un argumento prefijo está pasado para una función interactive escribiendo la tecla <META> seguido por un número, por ejemplo, @kdb{M-3 M-e}, o escribiendo @kdb{C-u} y entonces un número, por ejemplo, @kdb{C-u 3 M-e} (si se escribe @kdb{C-u} sin un número, por defecto a 4).

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.3.1 Un multiply-by-seven Interactivo

Permite mirar el uso de la forma especial interactive y entonces en la función message en la versión interactiva de multiply-by-seven. Se rellamará que la definición función se ve como esto:

 
(defun multiply-by-seven (number)       ; Versión Interactiva.
  "Multiplicar NUMERO por siete."
  (interactive "p")
  (message "The result is %d" (* 7 number)))

En esta función, la expresión, (interactive "p"), es una lista de dos elementos. El "p" cuenta Emacs a pasar el argumento prefijo a la función y usar su valor para el argumento de la función.

El argumento será un número. Esot significa que el símbolo número será emparejado para un número en la línea:

 
(message "The result is %d" (* 7 number))

Por ejemplo, si tu argumento prefijo es 5, el intérprete Lisp evaluará la línea como si fuera:

 
(message "The result is %d" (* 7 5))

(Si estás leyendo esto en GNU Emacs, se puede evaluar esta expresión por sí misma.) Primera, el intérprete evaluará la lista interna, que es (* 7 5). Esto devuelve un valor de 35. Lo siguiente, evaluará la lista externa, pasando los valores de la segunda y subsiguientes elementos de la lista a la función message.

Como hemos visto, message es una función Emacs Lisp especialmente diseñada para enviar una línea de mensaje a un usuario. (@xref{message, , La funci@'on @code{message}}) En resumen, la función message imprime su primer argumento en el área echo como es, excepto para ocurrencia de ‘%d’, o ‘%s’ (y varios otras %-secuencias que no hemos mencionado). Cuando se ve una secuencia de control, la función mira al segundo argumento o subsiguiente e imprime el valor del argumento en la localización en la cadena donde la secuencia de control está localizada.

En la función interactiva multiply-by-seven, la cadena de control es ‘%d’, que requiere un número, y el valor devuelto evaluando (* 7 5) es el número 35. Por consiguiente, el número 35 es impreso en lugar de ‘%d’ y el mensaje es ‘El resultado es 35’.

(Nótese que cuando llamas a la función multiply-by-seven, el mensaje está impreso sin comillas, pero cuando se llama a message, el texto es impreso con dobles comillas. Esto es porque el valor devuelto por message es que aparece en el área echo cuando se evalúa una expresión cuyo primer elemente es message; pero cuando se embebió en una función, message imprime el texto como un efecto lateral sin comillas.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.4 Opciones Diferentes para interactive

En el ejemplo, multipy-by-seven usado "p" como el argumento a interactive. Este argumento contó a Emacs para interpretar tu escritura si C-u seguido por un número o <META> seguido por un número como un comando para pasar este número a la función como su argumento. Emacs tiene más de veinte caracteres predefinidos para usar con interactive. En casi cada caso, una de estas opciones te habilitará para pasar la información adecuada interactivamente a una función. (Véase (elisp)Códigos Interactive sección `Carácteres Código para interactive' en El Manual de Referencia GNU Emacs Lisp).

Considera la función zap-to-char. Su expresión interactiva es

 
(interactive "p\ncZap to char: ")

La primera parte del argumento para interactive es ‘p’, con el que tu estás ya familiarizado. Este argumento cuenta a Emacs intepretar un `prefijo', como un número para ser pasado a la función. Tu puedes especificar un prefijo si escribiendo C-u seguidos por un número o escribiendo <META> seguido por un número. El prefijo es el número de caracteres especificados. De este modo, si tu prefijo es tres y el caracter especificado es ‘x’, entonces se borrará todo el texto e incluyendo el tercer ‘x’ siguiente. Si no se fija un prefijo, entonces borra todo el texto e incluye el carácter específico, pero no más.

El ‘c’ cuenta la función el nombre del carácter para que borre.

Más formalmente, una función con dos o más argumentos puede tener información pasado a cada argumento añadiendo partes para la cadena que sigue interactive. Cuando haces esto, la información está pasada para cada argumento en el mismo orden esto está especificado en la lista interactive. En la cadena, cada parte está separada desde la siguiente parte por un ‘\n’, que es una nueva línea. Por ejemplo, tu puedes seguir ‘p’ con un ‘\n’ y un ‘cZap to char:’. Esto causa que Emacs pase el valor del argumento prefijo (si hay uno) y el carácter.

En este caso, la definición de función mira como lo siguiente, donde arg y char son los símbolos para que interactive empareja el argumento y el caracter especificado:

 
(defun name-of-function (arg char)
  "documentation…"
  (interactive "p\ncZap to char: ")
  body-of-function…)

(El espacio después del punto y coma en pantalla hace que se vea mejor. Véase la sección La Definición de copy-to-buffer, por ejemplo.)

Cuando una función no tiene argumentos, interactive no requiere ninguno. Tal función cotiene la expresión simple (interactive). La función mark-whole-buffer es como esto.

Alternativamente, si los códigos de letras no son correctos para tu aplicación, se pueden pasar tus propios argumentos a interactive como una lista.

Véase la sección La Definición de append-to-buffer, para un ejemplo. Véase (elisp)Usando Interactive sección `Usando Interactive' en El Manual de GNU Emacs Lisp, para una explicación más completa acerca de esta técnica.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.5 Instalar Código Permanentemente

Cuando tu instales una definición de función evaluándolo, estará instalado hasta que salgas de Emacs. La siguiente vez que tu empieces una nueva sesión de Emacs, la función no será instalado a menos que tu evalúes la definición de nuevo.

En algún punto, tu puedes querer tener código instalado automáticamente siempre y cuando tu empieces una nueva sesión de Emacs. Hay varios caminos de hacer esto:

Finalmente, si tienes código que cualquiera que use Emacs puede querer, se puede enviar en una red de ordenadores o enviar una copia a la Free Software Foundation. (Cuando se hace esto, por favor, licencia el código y su documentación bajo una licencia que permita a otras personas ejecutar, copiar, estudiar, modificar, y redistribuir el código y que te protege desde quien tome tu trabajo.) Si tu envias una copia de tu código a la Free Software Foundation, y apropiadamente te protege a tí mismo y a otros, eso puede ser incluido en la siguiente entrega de Emacs. En la parte larga, esto es cómo Emacs ha crecido a través de los años pasados, por donaciones.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.6 let

La expresión let es una forma especial en Lisp que necesitarás para usar en la mayoría de las definiciones de función.

let es usada para adjuntar o emparejar un símbolo para un valor en tal camino que el intérprete no confundirá la variable con una variable del mismo nombre que no es parte de la función.

Para comprender por qué la forma especial let es necesaria, considera la situación en el que tu propio hogar que generalmente se refiere como `la casa', como en la frase, ``La casa necesita pintura.'' Si tu estás visitando a un amigo y tu alojamiento se refiere a `la casa', él es amistoso para estar refiriéndose a su casa, no la suya, que es, una casa diferente.

Si tu amigo está refiriéndose a su casa y tu piensas que él está refiriéndose a su casa, tu puedes estar dentro por alguna confusión. La misma cosa podría ocurrir en Lisp si una variable que es usada dentro de una función tiene el mismo que una variable que es usada dentro de otra función, y las dos no se pretende referirse al mismo valor. La forma especial let previene este tipo de confusión.

• Previniendo la confusión  
• Partes de la Expresión  
• Ejemplo de Expresión let  
3.6.3 Variables No Inicializadas en un Sentencia let  
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

let Evita Confusiones

La forma especial let evita confusiones. let crea un nombre para una variable local que ensombrece cualquier uso del mismo nombre fuera de la expresión let. Esto es como comprender que siempre y cuando tu host se refiera a `la casa', significa su casa, no la tuya. (Símbolos usados en listas de argumentos trabajan en el mismo camino. Véase la sección La Forma Especial defun.)

Las variable locales son creadas por una expresión let que retiene su valor solo con la expresión let por sí misma (y con expresiones llamadas con la expresión let); las variables locales no tiene efecto fuera de la expresión let.

Otro camino para pensar acerca de let es que es como un setq que es temporal y local. Los valores asignado por let son automáticamente deshechos cuando el let está finalizado. La configuración solo afecta a expresiones que están dentro de los emparejamientos de la expresión let. En jerga de ciencia de computación, diríamos que ``el emparejamiento de un símbolo es visible solo en funciones llamadas en la forma let; en Emacs Lisp, el alcance es dinámico, no léxico.''

let puede crear más de una variable a la vez. También, let da cada variable eso crea un valor inicial, si un valor especificado por tí, o nil. (En la jerga, eso se llama `asociar la variable al valor'.) Después let ha creado y asociado las variables, ejecuta el código en el cuerpo del let y devuelve el valor de la última expresión en el cuerpo, como el valor de la expresión let completa. (`Ejecuta' es un término de jerga que significa evaluar una lista: viene desde el uso de la palabra significando `dar efecto práctico a' (Diccionario de Inglés de Oxford). Desde que evalúas una expresión para ejecutar una acción, `ejecuta' ha evolucionado como un sinónimo para `evaluar'.)

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.6.1 Las Partes de una Expresión let

Una expresión let es una lista de tres partes. La primera parte es el símbolo let. La segunda parte es una lista, llamada una varlist, cada elemento de que es un símbolo por sí mismo o una lista de dos elementos, el primer elemento de que es un símbolo. La tercera parte de la expresión let es el cuerpo del let. El cuerpo normalmente consiste de una o más listas.

Una plantilla para una expresión let se parece a esto:

 
(let varlist body…)

Los símbolos en la varlist son las variables que son valores iniciales dados por la forma especial let. Los símbolos por sí mismos son dados por el valor inicial de nil; y cada símbolo que es el primer elemento de una lista de dos elementos es emparejado al valor que el devuelto cuando el intérprete Lisp evalúa el segundo elemento.

De este modo, una varlist podría verse como esto: (thread (needles 3)). En este caso, es una expresión let, Emacs asocia el símbolo thread a un valor inicial de nil, y empareja el símbolo needles a un valor inicial de 3.

Cuando escribes una expresión let, qué hacer es poner las expresiones apropiadas en las cajas de la plantilla de expresión let.

Si la lista de variables está compuesta de listas de 2 elementos, como es frecuente el caso, la plantillas para la expresión let mira como esto:

 
(let ((variable valor)
      (variable valor)
      …)
  body…)
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.6.2 Expresión Simple let

La expresión siguiente crea y da valores dados iniciales para las dos variables zebra y tiger. El cuerpo de la expresión let es una lista que llama a la función message.

 
(let ((zebra 'stripes)
      (tiger 'fierce))
  (message "Un tipo de animal tiene %s y otra es %s."
           zebra tiger))

Aquí, la varlist es ((zebra 'stripes) (tiger 'fierce)).

Las dos variables son zebra y tiger. Cada variable es el primer elemento de una lista de dos elementos y cada valor es el segundo elemento de su lista de dos elementos. En la varlist, Emacs asocia la variable zebra al valor stripes(8), y asocia la variable tiger al valor fierce. En este ejemplo, ambos valores son símbolos precedidos por una cita. Los valores podrían ser precedidos por una comilla. Los valores podrían también haber estado sin otra lista o una cadena. El cuerpo de let sigue después de la lista manejando las variables. En este ejemplo, el cuerpo es una lista que usa la función message para imprimir una cadena en el área echo.

Se puede evaluar el ejemplo en el modo usual, emplazando el cursor después de los últimos paréntesis y escribiendo @kdb{C-x C-e}. Cuando se hace esto lo siguiente aparecerá en el área echo:

 
"Un tipo de animal tiene rayas y otro es fiero"

Como se ha visto antes, la función message imprime su primer argumento, excepto por ‘%s’. En este ejemplo, el valor de la variable zebra es impreso en la posición del primer ‘%s’ y el valor de la variable tigre es impresa en la posición del segundo ‘%s’.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.6.3 Variables No Inicializadas en un Sentencia let

Si no asocia las variables en una frase let para valores específicos iniciales, ellos automáticamente emparejan a un valor inicial de nil, como en la siguiente expresión:

 
(let ((birch 3)
      pine
      fir
      (oak 'some))
  (message
   "Here are %d variables with %s, %s, and %s value."
   birch pine fir oak))

Aquí, la varlist es ((birch 3) pine fir (oak 'some)).

Si se evalúa esta expresión en el modo usual, aparecerá lo siguiente en el área echo:

 
"Aquí están 3 variables con nil, nil, y algún valor".

En este ejemplo, Emacs empareja el símbolo birch al número 3, empareja los símbolos pine y fir a nil, y empareja el símbolo oak al valor some.

Note que en la primera parte del let, las variables pine y fir se aloja solo como átomos que no están rodeados por paréntesis; esto es porque están siendo emparejados a nil, la lista vacía. Pero oak es emparejado a some y así es una parte de la lista (oak 'some). De manera similar, birch está emparejado al número 3 y así es una lista con este número. (Desde que un número evalúa por sí mismo, el número no necesita ser citado. También, el número es impreso en el mensaje usando ‘%d’ en vez de un ‘%s’.) Las cuatro variables como un grupo son puestos dentro de una lista para delimitarlos desde el cuerpo del let.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.7 La Forma Especial if

Una tercera forma especial, además de defun y let, es el condicional if. Esta forma es usada para instruir el ordenador para crear decisiones. Se puede escribir definiciones de función usando if, pero eso es usado con suficiente frecuencia, y es suficientemente importante para ser incluido aquí. Eso es usado, por ejemplo, en el código para la función beginning-of-buffer.

La idea básica de un if, es que ``if un test es verdad then una expresión es evaluado.'' Si el test no es verdad, la expresión no está evaluada. Por ejemplo, podría crear una decisión tal y como, ``¡si es cálido y soleado, entonces a la playa!''

if en más detalle  
3.7.1 La Función type-of-animal en Detalle   Un ejemplo de una expresión if.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

if en más detalle

Una expresión if expresión escrita en Lisp no usa la palabra `then'; el test y la acción son el segundo y tercer elementos de la lista cuyo primer elemento es if. Ninguno menos, la parte de test de una expresión if es con frecuencia llamada la if-part y el segundo argumento es con frecuencia llamada la then-part.

También, cuando una expresión if es escrita, el true-or-false-test es normalmente escrito en la misma línea como el símbolo if, pero la acción para traer si el test es verdadero, el ``then-part'', es escrita en la segunda y subsiguientes líneas. Este hace la expresión if es fácil de leer.

 
(if true-or-false-test
    accion-a-realizar-si-el-test-es-cierto)

El true-or-false-test será una expresión que es evaluado por el intérprete Lisp.

Aquí hay un ejemplo que se puede evaluar en la manera normal. El test es si el número 5 es mayor que el número 4. Desde eso, el mensaje ‘5 es más grande que 4’ será impreso.

 
(if (> 5 4)                             ; if-part
    (message "5 es mayor que 4!"))   ; then-part

(La función > chequea si su primer argumento es mayor que su segundo argumento y devuelve cierto si lo es.)

De acuerdo, en uso actual, el test en una expresión if no será corregido para todo el tiempo como eso es por la expresión (> 5 4). En vez, al menos una de las variables usadas en el test será asociada a un valor que no es conocido en frente del tiempo. (Si el valor fuera conocido en el tiempo, ¡no necesitaríamos ejecutar el test!)

Por ejemplo, el valor puede ser asociado a un argumento de una definición de función. En la siguiente definición de función, el carácter del animal es un valor que es pasado a la función. Si el valor asociado a característico es fiera, entonces el mensaje, ‘Es un tigre!’ será impreso; de otro modo, nil será devuelto.

 
(defun type-of-animal (characteristic)
  "Imprime el mensaje en el área echo dependiendo de CHARACTERISTIC.
Si la CHARACTERISTIC es el símbolo `fiera',
entonces avisa de un tigre."
  (if (equal characteristic 'fiera)
      (message "¡Es un tigre!")))

Si estás leyendo esto dentro de GNU Emacs, se puede evaluar la definición función en el modo usual para instalarlo en Emacs, y entonces se puede evaluar las siguientes dos expresiones para ver los resultados:

 
(type-of-animal 'fierce)

(type-of-animal 'zebra)

Cuando evalúas (type-of-animal 'fierce), verás el siguiente mensaje impreso en el área echo: "Es un tigre!"; y cuando se evalúa (type-of-animal 'zebra) verás nil impreso en el área echo.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.7.1 La Función type-of-animal en Detalle

Mira la función type-of-animal en detalle.

La definición de función para type-of-animal fué escrito para rellenar los slots de dos plantillas, uno para una definición de función como un todo, y un segundo para una expresión if.

La plantilla para cada función que no es interactiva es:

 
(defun name-of-function (argument-list)
  "documentation…"
  body…)

Las partes de la función asociada a esta plantilla es:

 
(defun type-of-animal (characteristic)
  "Imprime el mensaje en el área echo dependiendo de CHARACTERISTIC.
Si la CHARACTERISTIC es el símbolo `fierce',
entonces avisa de un tigre."
  body: the if expression)

El nombre de función es type-of-animal; eso es pasado el valor de un argumento. La lista de argumentos es seguida por una cadena de documentación multi-línea. La cadena de documentación es incluida en el ejemplo porque es un buen hábito para escribir documentación para cada definición de función. El cuerpo de la definición de función consiste de la expresión if.

La plantilla para una expresión if se ve así:

 
(if true-or-false-test
    action-to-carry-out-if-the-test-returns-true)

En la función type-of-animal, el código para el if es este:

 
(if (equal characteristic 'fierce)
    (message "It's a tiger!")))

Aquí, está la expresión true-or-false-test

 
(equal characteristic 'fierce)

En Lisp, equal es una función que determina si su primer argumento es igual para su segundo argumento. El segundo argumento es el símbolo citado 'fierce y el primer argumento es el valor del símbolo característico --- en otras palabras, el argumento pasado a esta función.

En el primer ejercicio de type-of-animal, el argumento fierce es pasado a type-of-animal. Desde que fierce es igual a fierce, la expresión, (equal characteristic 'fierce), devuelve un valor de verdad. Cuando esto ocurre, el if evalúa el segundo argumento o then-part del if: (message "¡Es un tigre!").

Por otro lado, en el segundo ejercicio de type-of-animal, el argumento zebra es pasado a type-of-animal. zebra no es igual a fierce, así la then-part no está evaluada y nil es devuelto por la expresión if.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.8 Expresiones If–then–else

Una expresión if puede tener un tercer argumento opcional, llamado la else-part, para el caso en el que true-or-false-test devuelve falso. Cuando esto ocurre, el segundo argumento o el then-part de sobre todo la expresión if no es evaluado, pero el tercero o la else-part es evaluado. Se podría pensar en esto como la alternativa del día nublado para la decisión ``si eso es cálido y soleado, ve a la playa, sino lee un libro!''

La palabra ``else'' no está escrita en el código Lisp; la parte else de una expresión if viene después de la parte then. En el Lisp escrito, parte else es normalmente escrita para empezar en una línea de sí mismo y está menos indentada que la parte then:

 
(if true-or-false-test
    action-to-carry-out-if-the-test-returns-true
  action-to-carry-out-if-the-test-returns-false)

Por ejemplo, la siguiente expresión if imprime el mensaje ‘4 no es más grato que 5’ cuando se evalúa eso en el camino usual:

 
(if (> 4 5)                               ; if-part
    (message "4 no es más grande que 5!") ; then-part
  (message "4 no es más grande que 5!"))   ; else-part

Nótese que los diferentes niveles de indentación hacen fácil distinguir la parte then desde la parte else. (GNU Emacs tiene varios comandos que automáticamente indenta expresiones correctamente if. @xref{Escribiendo Listas GNU Emacs te Ayuda a Escribir Listas}.)

Podemos extender la función type-of-animal para incluir una parte else para simplemente incorporar una parte adicional para la expresión if.

Se puede ver las consecuencias de hacer esto si se evalúa la siguiente versión de la definición de función type-of-animal para instalarlo y entonces evaluar las dos expresiones subsiguientes para pasar diferentes argumentos para la función.

 
(defun type-of-animal (characteristic)  ; Second version.
  "Imprime el mensaje en el área echo dependiendo de CHARACTERISTIC.
Si la CHARACTERISTIC es el símbolo `fiera',
entonces avisa de un tigre;
sino di no es una fiera."
  (if (equal characteristic 'fiera)
      (message "¡Es un tigre!")
    (message "¡No es una fiera!")))

 
(type-of-animal 'fierce)

(type-of-animal 'zebra)

Cuando se evalúa (type-of-animal 'fierce), verás el siguiente mensaje impreso en el área echo: "Eso es un tigre"; pero cuando se evalúa (type-of-animal 'zebra), verás "No es una fiera".

(De acuerdo, si la característica fuera feroz, el mensaje "No es una fiera!" sería impreso; y estaría mal liderado! Cuando se escribe código, se necesita tener en cuenta la posibilidad que algunos argumentos será probado por if y escribir tu programa de acuerdo.

[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

3.9 Verdad y Falsedad en Emacs Lisp

Hay un aspecto importante para el test de verdad en una expresión if. Así, hemos hablado de `verdad' y `mentira' como valores de predicados como si fueran nuevos tipos de objetos Emacs Lisp. En efecto, `falso' es solo nuestro viejo amigo nil. Cualquier cosa más --- cualquier cosa en todo --- es `verdad'.

La expresión chequea que verdad es interpretado como true si el resultado de evaluarlo es un valor que no es nil. En otras palabras, el resultado del test es considerado cierto si el valor devuelto es un número como 47, una cadena tal como "hello", o un símbolo (otro como nil) tal como flores, o una lista (tan larga como eso no está vacía) ¡o incluso un búffer!

Una explicación de nil   nil tiene dos significados.
[ < ] [ > ]   [ << ] [ Subir ] [ >> ]         [Arriba] [Índice general] [Índice] [ ? ]

Una explicación de nil

Antes de ilustrar un test para verdad, se necesita una explicación de nil.

En Emacs Lisp, el símbolo nil tiene dos significados. Primero, está el significado de la lista vacía. Segundo, está el valor de falso y es el valor devuelto cuando el test true-or-false-test salga falso. nil. Tan lejos como el intérprete Lisp es concebido, () y nil son el mismo. Los humanos, sin embargo, tienden a usar nil para falso y () para la lista vacía.

En Emacs Lisp, cualquier valor que no es nil --- no es una lista vacía --- es considerado verdad. Esto significa que si una evaluación devuelve alguna cosa que no es una lista vacía, una expresión if devuelve verdad. Por ejemplo, si un número es puesto en el slot para el test, será evaluado y devolverá por sí mismo, desde lo que hacen los números cuando se evalúan. En este condicional, la expresión if devuelve verdad. La expresión se chequea como falso solo cuando nil, una lista vacía, es devuelta evaluando la expresión.

Se puede ver esto evaluando las dos expresiones en los siguientes ejemplos.

En el primer ejemplo, número 4 es evaluado como el test en la expresión if y se devuelve por sí mismo; por consiguiente, la then-part de la expresión es evaluada y devuelta: ‘true’ aparece en el área echo. En el segundo ejemplo, nil indica falso; por consiguiente, el else-part de la expresión es evaluada y devuelta: ‘false’ aparece en el área echo.

 
(if 4
    'true
  'false)

(if nil
    'true
  'false)




Incidentalmente, si algún otro valor útil no está disponible
para un test que devuelve cierto, entonces el intérprete Lisp
retornará el símbolo t para cierto. Por
ejemplo, la expresión (> 5 4) devuelve t cuando se
evalúa, como puedes ver evaluándolo en el camino usual:



 
(> 5 4)




Por otro lado, esta función devuelve nil si el test es falso.



 
(> 4 5)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




3.10 save-excursion









La función save-excursion es la cuarta y última forma especial
que se discutirá en este en este capítulo.



En Emacs Lisp hay programas usados para edición, la función
save-excursion es muy común. Eso guarda la posición de
punto y marca, ejecuta el cuerpo de la función, y entonces restaura
el punto y marca a sus posiciones previas si sus posiciones fueran
cambiadas. Su propósito primario es guardar que el usuario sea
sorprendido y molesto por movimientos inesperado de punto y marca.





Punto y Marca              Una revisión de varias localizaciones.



3.10.1 Plantilla para una Expresión save-excursion    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Punto y Marca



Antes de discutir save-excursion, sin embargo, puede ser útil
primero revisar que punto y marca están en GNU Emacs. Punto es
la posición actual del cursor. En cualquier lugar que el cursor se
posicione hay un punto. De manera más precisa, en terminales donde
el cursor parece estar en lo alto de un carácter, el punto está
inmediatamente antes del carácter. En Emacs Lisp, punto es un
entero. El primer caracter en un búffer es el número uno, el segundo
es el número dos, y así. La función punto
devuelve la posición actual del cursor como un número. Cada
búffer tiene su propio valor para el punto.



La marca es otra posición en el búffer; su valor puede ser
asignado con un comando tal como @kdb{C-<SPC>}
(set-mark-command). Si una marca ha sido asignada, se puede
usar el comando C-x C-x (exchange-point-and-mark) para
hacer que el cursor salte a la marca y asignar la marca para la
posición previa del punto. Además, si tu asignas otra marca, la
posición puede ser guardada por este camino. Se puede saltar al
cursor para una marca guardada escribiendo @kdb{C-u C-<SPC>} una o
más veces.



La parte del búffer entre el punto y la marca es llamada la
región. Numerosos comandos trabajan en la región, incluyendo
center-region, count-lines-region, kill-region y
print-region.



La forma especial save-excursion salva las posiciones del punto
y la marca y restaura estas posiciones después del código con el
cuerpo de la forma especial es evaluada por el intérprete Lisp. De
este modo, si el punto fuera en el principio de una pieza de texto y
algún código movido apunta al fin del búffer, el
save-excursion no apuntaría a donde fué antes,
después las expresiones en el cuerpo de la fueron evaluadas.



En Emacs, una función frecuentemente mueve el punto como parte de
sus trabajos internos incluso aunque un usuario no espere esto. Por
ejemplo, count-lines-region se mueve al punto. Para prevenir al
usuario que se preocupe por salto que es inesperado y (desde el punto
de vista del usuario) innecesario, save-excursion es con
frecuencia usado para punto y marca en la posición esperada por el
usuario. El uso de save-excursion es un buen guarda casas.



Para estar seguro que la casa está limpia, save-excursion
restaura los valores de punto y marca incluso si alguna cosa va mal en
el código dentro de eso (o, para ser más preciso y usar la jerga
apropiada, ``en caso de salida anormal''). Esta funcionalidad es muy
útil.



Además grabando los valores de punto y marca, save-excursion
guarda la traza del actual buffer, y lo restaura, también. Esto
significa que puedes escribir código que cambiará el buffer y
tener que save-excursion vuelva al buffer original. Esto es como
save-excursion es usado en
append-to-buffer. (Véase la sección  La Definición de append-to-buffer.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




3.10.1 Plantilla para una Expresión save-excursion



La plantilla para código usando save-excursion es simple:



 
(save-excursion
  body…)




El cuerpo de la función es una o más expresiones que serán
evaluadas en secuencia por el intérprete Lisp. Si hay más de una
expresión en el cuerpo, el valor de la última será devuelto como
el valor de la función save-excursion. Las otras expresiones
en el cuerpo son evaluadas solo por sus efectos laterales; y
save-excursion en sí es usado solo por su efecto
lateral (que está restaurando las posiciones de punto y marca).



Para más detalles, la siguiente plantilla explica save-excursion



 
(save-excursion
  primera-expresion-en-el-cuerpo
  segunda-expresion-en-el-cuerpo
  tercera-expresion-en-el-cuerpo
   …
  ultima-expresion-en-el-cuerpo)




Una expresión, de acuerdo, puede ser un símbolo por
sí mismo o una lista.



En código Emacs Lisp, una expresión save-excursion con
frecuencia ocurre el cuerpo de una expresión let. Eso se ve
como esto:



 
(let varlist
  (save-excursion
    body…))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




3.11 Revisar



En los últimos pocos capítulos se han introducido un
número limpio de funciones y formas especiales. Aquí
se han descrito brevemente, con unas pocas funciones similares que no
han sido mencionadas todavía.





 eval-last-sexp


Evalúa la última expresión simbólica antes de la posición
actual del punto. El valor es impreso en el área echo a menos
que la función sea invocada con un argumento; en este caso, la salida
es impresa en el actual búffer. Este comando está normalmente
asociado a C-x C-e.





 defun


Definir función. Esta forma especial ha subido a cinco partes: el
nombre una plantilla para los argumentos que serán pasados a la
documentación de la función, una declaración interactiva
opcional, y el cuerpo de la definición.



Por ejemplo, en las primeras versiones de Emacs, la definición de
función era como sigue. (Eso es ligeramente más complejo ahora que
si busca el primer caracter de espacio no en blanco en vez del primer
caracter visible.)



 
(defun back-to-indentation ()
  "Mover el punto al primer caracter visible en linea."
  (interactive)
  (beginning-of-line 1)
  (skip-chars-forward " \t"))







 interactive


Declara al intérprete que la función puede ser usada
interactivamente. Esta forma especial puede ser seguida por una cadena
con una o más partes que pasan la información a los argumentos de
la función, en secuencia. Estas partes pueden también contar al
intérprete para mostrar la información. Parte de las cadenas son
separadas por nuevas líneas, ‘\n’.



Caracteres de código común son:





 b


El nombre de un búffer existente.





 f


El nombre de un fichero existente





 p


El argumento prefijo numérico. (Nótese que esta `p' es minúscula.)





 r


El Punto y la marca, como dos argumentos numéricos, el más
pequeño primero. Esta es la única letra que especifica dos
argumentos sucesivos en vez de uno.






Véase (elisp)Códigos Interactivos sección `Caracteres de Código para ‘interactive’' en El Manual de Referencia de GNU Emacs Lisp,
para una lista de caracteres de código.





 let


Declara que una lista de variables es para usarla con el cuerpo del
let y darles un valor inicial, bien nil o un valor
específico; entonces se evaluarán el resto de las
expresiones en el cuerpo del let y devolver el valor de la
última. Dentro del cuerpo del let, el intérprete Lisp no ve
los valores de las variables de los mismos nombres que son asociados
fuera del let.



Por ejemplo,



 
(let ((foo (buffer-name))
      (bar (buffer-size)))
  (message
   "Este buffer es %s y tiene %d caracteres."
   foo bar))






 save-excursion


Graba los valores de punto y marca y el actual búffer antes de evaluar
el cuerpo de esta forma especial. Restaura los valores de punto y
marca y el búffer después de esto.



Por ejemplo,



 
(message "Hay %d caracteres dentro de este buffer."
         (- (point)
            (save-excursion
              (goto-char (point-min)) (point))))






 if


Evalúa el primer argumento a la función; si es verdad, evalúa el
segundo argumento; lo demás evalúa el tercer argumento, si hay uno.



La forma especial if es llamada condicional. Hay otros
condicionales en Emacs Lisp, pero if es quizás lo más
comúnmente usado.



Por ejemplo,



 
(if (= 22 emacs-major-version)
    (message "Esta es la versión 22 de Emacs")
  (message "Esta no es la versión 22 Emacs"))






 <


 >


 <=


 >=


La función < chequea si su primer argumento es más pequeño
que su segundo argumento. Una función correspondiente, >,
chequea si el primer argumento es mayor que el segundo. De otro modo,
<= chequea si el primer argumento es menor o igual al segundo y
>= chequea si el primer argumento es mayor o igual al
segundo. En todos los casos, ambos argumentos deben ser números o
marcas (las marcas indican posiciones en búffers).





 =


La función = chequea si dos argumentos, ambos números o
marcadores, son iguales.





 igual


 eq


Chequea si dos objetos son el mismo. equal usa un signicado de
la palabra `mismo' y eq usa otro: equal devuelve cierto
si los dos objetos tienen una estructura y contenidos similares, tal
como dos copias del mismo libro. En una mano, eq, devuelve
cierto si ambos argumentos son actualmente el mismo objeto.







 string<


 string-lessp


 string=


 string-equal


La función string-lessp chequea si su primer argumento es
más pequeño que el segundo. En resumen, el nombre alternativo para
la misma función (un defalias) es string.



Los argumentos para string-lessp deben ser cadenas o
símbolos; la ordenación es lexicográfica,
así el caso es significativo. Los nombres impresos de
símbolos son usado en vez de símbolos por
sí mismos.




Una cadena vacía, ‘"\"’, una cadena sin caracteres
dentro, es más pequeña que cualquier cadena de caracteres.



string-equal provee el test correpondiente para igualdad. Su
corto nombre alternativo es string=. No hay funciones test que
correponden a >, >=.





 mensaje


Imprime un mensaje en el área echo. El primer argumento es una
cadena que puede contener, ‘%s’, ‘%d’, o ‘%c’ para
imprimir el valor de argumentos que siguen la cadena. El argumento
usado por ‘%d’ debe ser un número. El argumento usado por
‘%c’ debe ser un número de código ASCII; eso será
impreso como el caracter con este código ASCII. (Otras varias
%-secuencias no han sido mencionadas.)





 setq


 set


La función setq asigna el valor de su primer argumento al
valor del segundo argumento. El primer argumento está
automáticamente citado por setq. Eso hace lo mismo para los
pares de argumentos. Otra función, set, toma solo dos
argumentos y evalúa ambos de ellos antes de configurar el valor
devuelto por su primer argumento al valor devuelto por su segundo argumento.





 buffer-name


Sin un argumento, devuelve el nombre del búffer, como una cadena.





 buffer-file-name


Sin un argumento, devuelve el nombre del fichero si el búffer lo está
visitando.





 current-buffer


Devuelve el búffer en el que Emacs es activo; eso puede no ser el
búffer que es visible en la pantalla.





 other-buffer


Devuelve el búffer seleccionado más recientemente (otro que el
búffer pasado a other-buffer como un argumento y otro en vez
de el búffer actual).





 switch-to-buffer


Selecciona un búffer para Emacs esté activo y lo muestre en la
ventana actual y así los usuarios puedan
mirarlo. Normalmente se empareja a C-x b.





 set-buffer


Cambia la atención de Emacs a un búffer en el que los programas se
ejecutarán. No altera lo que la ventana está mostrando.





 buffer-size


Devuelve el número de caracteres en el búffer actual.





 punto


Devuelve el valor de la actual posición del cursor, como un entero
contando el número de caracteres desde el principio del búffer.





 point-min


Devuelve el valor mínimo permisible del punto en el
búffer actual. Esto es 1, a menos que la contracción esté en efecto





 point-max


Devuelve el valor del máximo valor permisible del punto en el
búffer actual. Esto es el fin del búffer, a menos que la
contracción esté en efecto











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




3.12 Ejercicios










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4. Unas pocas funciones de buffer relacionadas



En este capítulo estudiamos en detalle varias de las
funciones usadas en GNU Emacs. Esto se llama un ``paseo a
través''. Estas funciones son usadas como ejemplos de código Lisp,
pero no son ejemplos imaginarios; con la excepción del primero, la
definición de función simplificada, esta funciones muestran el
actual código usado en GNU Emacs. Se puede aprender un gran trato
desde estas definiciones. Las funciones descritas aquí
están todas relacionadas a búffers. Después, estudiaremos otras
funciones.





4.1 Encontrando Más Información          Cómo encontrar más información.



4.2 Una Definición Simplificada beginning-of-buffer    Muestra goto-char, 
                                      point-min, y push-mark.



4.3 La Definición de mark-whole-buffer          Casi lo mismo que beginning-of-buffer.



4.4 La Definición de append-to-buffer           Usa save-excursion y 
                               insert-buffer-substring.



4.5 Revisar    Revisa



4.6 Ejercicios       











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.1 Encontrando Más Información





En este paseo, se describe cada nueva función como viene, algunas
veces en detalle y algunas veces brevemente. Si está interesado, se
puede obtener la documentación completa de cualquier función Emacs
Lisp en cualquier momento escribiendo C-h f y entonces el
nombre de la función (y entonces <RET>. De manera similar, se
puede obtener la documentación completa para una variable
escribiendo C-h v, después el nombre de la variable (y
entonces <RET>).




También, en describe-function, se encontrará la localización
de la definición de la función.



Poner el punto dentro del nombre del fichero que contiene la función
y presiona la tecla <RET>. En este caso, <RET> significa
push-button en vez de `return' o `enter'. Emacs tomará
directamente a la definición de la función.




De manera más general, si quieres ver una función en su fichero
fuente original, se puede usar la función find-tag para
saltar dentro. find-tag funciona con una amplia variedad de
lenguajes, no solo Lisp, y C, y funciona con texto de no
programación también. Por ejemplo, find-tag saltará a los
varios nodos en el fichero fuente Texinfo de este documento. La
función find-tag depende de `tablas de etiquetas' que graba
las localizaciones de las funciones, variables, y otros
ítems para los que find-tag salta.



Para usar el comando find-tag, escribe M-. (por ej.,
presiona la tecla <.> mientras se pulsa la tecla <META>, o al
menos escribe la tecla <ESC> y entonces escribe la otra tecla), y
entonces, en la pantalla, escribe el nombre de la función cuyo
código fuente se quiere ver, tal como mark-whole-buffer, y
luego escribe <RET>. Emacs cambiará el búffer y mostrará el
código fuente para la función en tu pantalla. Para volver desde tu
búffer actual a tu búffer actual, escribe C-x b
<RET>. (En algunos teclados, la tecla <META> es etiqueta con
<ALT>.)





Dependiendo de cómo los valores iniciales por defecto de tu copia de
Emacs son asignados se puede también necesitar especificar la
posición de tu `tabla de tags', que es un fichero llamado
‘TAGS’. Por ejemplo, si se está interesado en fuentes de Emacs,
la tabla de tags que se desea, si ya ha sido creada para
tí, estará en un subdirectorio del directorio
‘/usr/local/share/emacs’; de este modo se usaría el
comando {M-x visit-tags-table y especifica una ruta tal como
‘/usr/local/share/emacs/22.1.1/lisp/TAGS’. Si la tabla tags no ha
sido creada, tendrás que crearla por tí mismo. Será
un fichero tal como ‘/usr/local/src/emacs/src/TAGS’.



Para crear un fichero ‘TAGS’ en un directorio
específico, cambia a este directorio en Emacs usando
un comando @kdb{M-x cd}, o lista el directorio como etags
*.el como el comando para ejecutar:



 
M-x compile RET etags *.el RET




Para más información, ver Crea tu propio fichero ‘TAGS’.



Después de llegar a estar más familiarizado con Emacs Lisp,
se encontrará frecuentemente usar find-tag para navegar tu
camino alrededor del código fuente; y se crearán tus propias tablas
‘TAGS’.




Incidentalmente, los ficheros que contienen código Lisp son
convencionalmente llamadas librerías. La
metáfora se deriva que una librería, tal como
la librería de leyes o una librería de
ingeniería, en vez de una librería
general. Cada librería, o fichero, contiene funciones
que se relacionan a un asunto particular o actividad, tal como
‘abbrev.el’ para manejar abreviaciones y otros atajos, y
‘help.el’ para la ayuda on-line. (Algunas veces varias
librerías proporcionan código para una actividad
simple, como varios ‘rmail…’ ficheros proveen código para
leer correos electrónicos.) En El Manual de GNU Emacs, tu
verás varias frases tales como ``El comando C-h p te permite
buscar el estándar de las librerías Emacs Lisp por las
palabras claves.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.2 Una Definición Simplificada beginning-of-buffer




El comando beginning-of-buffer es una buena función para
empezar ya puedes tener cierta familiaridad con eso y es fácil de
comprender. Usado como un comando interactivo,
beginning-of-buffer mueve el cursor al principio del búffer,
dejando la marca en la posición previa. Eso es generalmente
asignados a M-<.



En esta sección, se discutirá una versión ordenada de la
función que muestra como eso es lo usado más frecuentemente. Esta
función ordenada trabaja como se escribe, pero no contiene el
código para una función compleja. En otra sección, describiremos
la función entera. (Véase la sección  Definición Completa de beginnning-of-buffer.)



Antes de mirar en el código, permítenos considerar que
la definición de función tiene que contener: eso debe incluir una
expresión que crea la función interactiva así puede
ser llamado escribiendo M-x beginning-of-buffer o escribiendo
unos atajos tales como M-<; debe incluir código para dejar una
marca en la posición original en el búffer; y debe incluir
código el cursor al principio del búffer.



Aquí está el texto completo la versión ordenada de
la función:



 
(defun simplified-beginning-of-buffer ()
  "Mover punto al principio del bufer; dejar marca en la posición previa."
  (interactive)
  (push-mark)
  (goto-char (point-min)))




Como todas las definiciones de función, esta definición tiene
cinco partes siguiendo la forma especial defun:



    

  1. 
El nombre: en este ejemplo, simplified-beginning-of-buffer.


  2. 
Una lista de los argumentos: en este ejemplo, una lista
vacía, (),


  3. 
La cadena de documentación.


  4. 
La expresión interactive.


  5. 
El cuerpo.




En esta definición de función, la lista de argumentos está
vacía; esto significa que esta función no requiere
argumentos. (Cuando se busca la definición para la función
completa, se verá que puede pasarse un argumento opcional.)



La expresión interactiva cuenta a Emacs que la función se pretende
ser usada interactivamente. En este ejemplo, interactive no
tiene un argumento porque simplified-beginning-of-buffer no se
requiere.



El cuerpo de la función consiste de dos líneas:



 
(push-mark)
(goto-char (point-min))




La primera de estas líneas es la expresión,
(push-mark). Cuando esta expresión es evaluado por el
intérprete Lisp, eso asigna una marca en la posición actual del
cursor, siempre y cuando esto pueda ser. La posición de esta marca
está guardada en el anillo de marcas.



La siguiente línea es (goto-char
(point-min)). Esta expresión salta el cursor al punto
mínimo en el búffer, esto es, para el comienzo del
búffer (o al principio de la porción accesible del búffer si eso
está encogido. Véase la sección  Extendiendo y Encogiendo.)



El comando push-mark estable una marca en el lugar donde el
cursor fué localizado antes que fuera movido al principio del
búffer por la expresión (goto-char
(point-min)). Consiguientemente, puedes, si lo deseas, volver donde
estabas originalmente escribiendo C-x C-x.



¡Esto es todo lo que hay para la definición de función!




Cuando se lee código como este y vuelve a una función no familiar,
tal como goto-char, se puede encontrar que se hace usando el
comando describe-function. Para usar este comando, escribe
@kdb{C-h f} y entonces escribe en el nombre de la función y presiona
<RET>. El comando describe-function imprimirá la
documentaciń de la cadena de la  función en una ventana
‘*Help*’. Por ejemplo, la documentación para goto-char es:



 
Asignar punto a POSITION, un número o marca
Empezando el buffer es la posición (point-min), y el final es (point-max).



La función es un argumento es la posición deseada.



(La consola para describe-function te ofrecerá el
símbolo abajo o precediendo al cursor, así
se puede guardar escribiendo al posiciona el cursor a la derecha o
después de la función y entonces escribiendo C-h f <RET>.)



La definición de función end-of-buffer está escrito en el
mismo modo que la definición beginnig-of-buffer excepto que
el cuerpo de la función contenga la expresión (goto-char
(point-max)) en lugar de (goto-char (point-min))








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.3 La Definición de mark-whole-buffer




La función mark-whole-buffer no es tan difícil de
comprender que la función simplified-beginning-of-buffer. En
este caso, sin embargo, se verá la función completa, no una
versión ordenada.



La función mark-whole-buffer no está comúnmente usada
como la función beginning-of-buffer, pero eso no es útil:
eso marca un búffer completo como una región poniendo el punto al
principio y una marca al fin del búffer. Eso está generalmente
asociado a C-x h.





• resumen de mark-whole-buffer  



4.3.1 Cuerpo de mark-whole-buffer    Solo tres líneas de código.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Un resumen de mark-whole-buffer



En GNU Emacs 22, el código para la función completa se parece a:



 
(defun mark-whole-buffer ()
  "Pon el punto al principio y marca el fin del búffer. 
Probablemante no deberías usar esta función en
  programas Lisp; normalmente un error para una función Lisp usa
  cualquier subrrutina que usa o asigna la marca."
  (interactive)
  (push-mark (point))
  (push-mark (point-max) nil t)
  (goto-char (point-min)))




Como todas las otras funciones, la función mark-whole-buffer
se ajusta dentro de la plantilla para una definición. La plantilla
se parece a esta:



 
(defun name-of-function (argument-list)
  "documentation…"
  (interactive-expression…)
  body…)




Aquí está cómo la función trabaja: el nombre de la
función es mark-whole-buffer; eso es seguida por un argumento
de lista vacía, ‘()’, que significa que la
función no requiere argumentos. La documentación viene la siguiente.



La siguiente línea es una expresión
(interactive) que cuenta a Emacs que la función será usada
interactivamente. Estos detalles son similares a la función
simplified-beginning-of-buffer descrita en la sección previa








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.3.1 Cuerpo de mark-whole-buffer



El cuerpo de la función mark-whole-buffer consiste en tres
líneas de código:



 
(push-mark (point))
(push-mark (point-max) nil t)
(goto-char (point-min))




El primero de estas líneas es la expresión,
(push-mark (point)).



Esta línea hace exactamente el mismo trabajo que la
primera línea del cuerpo de la función
simplified-beginning-of-buffer, que está escrita
(push-mark). En ambos casos, el intérprete Lisp asigna una
marca en la posición actual del cursor.



No sé por qué en la expresión mark-whole-buffer está
escrito (push-mark (point)) y en la expresión
beginning-of-buffer está escrito (push-mark). Quizás
quien escribió el código no sabía que los argumentos
para push-mark son opcionales y que si push-mark no se
pasa como argumento, la función automáticamente asigna la marca en
la localización del punto por defecto. O quizás la expresión
fué escrita así como para parelizar la estructura de
la siguiente línea. En cualquier caso, la
línea causa que Emacs determine la posición del
punto y asigne una marca allí.



En las primeras versiones de GNU Emacs, la siguiente
línea de mark-whole-buffer fué (push-mark
(point-max)). Esta expresión asigna una marca en el punto en el
búffer que tiene el número más alto. Esto será el fin del
búffer (o, si el búffer es encogida, el fin de la porción
accesible del búffer. Véase la sección  Extendiendo y Encogiendo, para más acerca encoger.) Después esta marca ha sido
asignada, la marca previa, uno asigna un punto, no es se asigna largo,
pero Emacs recuerda su posición, solo como todas las otras marcas
recientes son siempre recordadas. Esto significa que tu puedes, si lo
deseas, vuelve a esta posición escribiendo C-u C-<SPC> dos
veces.



En GNU Emacs 22, el (point-max) es ligeramente más
complicado. La línea lee



 
(push-mark (point-max) nil t)




La expresión funciona cerca de lo mismo que antes. Eso asigna una marca
en el lugar numerado más alto que se puede en el búffer. Sin
embargo, en esta versión, push-mark tiene dos argumentos
adicionales. El segundo argumento para push-mark es
nil. Esto cuenta la función que
mostraría un mensaje que dice `Marca asignada'
cuando eso empuja la marca. El tercer argumento es t. Esto
cuenta push-mark para activar la marca cuando el modo Transient
Mark está activado. Transient Mark mode ilumina la región de marca
activa. Con frecuencia desactivada



Finalmente, la última línea de la función es
(goto-char (point-min)). Esto es escrito exactamente el mismo
camino camino como está escrito beginning-of-buffer. La
expresión mueve el cursor al mínimo punto en el
búffer, que es, al principio del búfferr (o para el principio de
la porción accesible del búffer). Como un resultado de esto, punto
está emplazado al principio del búffer y marca está asignada al
fin del búffer. El búffer completo es, más allá, la región.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.4 La Definición de append-to-buffer




El comando append-to-buffer es más complejo que el comando
mark-whole-buffer. Lo que hace es copiar la región (que es,
la parte del búffer entre punto y marca) desde el buffer actual a un
búffer específico.





Un Resumen de append-to-buffer  



4.4.1 La Expresión Interactiva append-to-buffer         Una expresión interactiva de dos partes.



4.4.2 El Cuerpo de append-to-buffer    Incorpora una expresión let.



4.4.3 save-excursion en append-to-buffer      Cómo save-excursion trabaja.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Un Resumen de append-to-buffer




El comando append-to-buffer usa la función
insert-buffer-substring para copiar la
región. insert-buffer-substring es descrita por su nombre:
eso toma una cadena de caracteres desde parte de un búffer, una
``subcadena'', y las inserta dentro de otro búffer.



La mayoría de append-to-buffer se refiere con la
configuración de las condiciones para insert-buffer-substring
para trabajar: el código debe especificar ambos el búffer para el
que el texto irá, la ventana viene y va, y la región que será copiada.



Aquí está el texto completo de la función:



 
(defun append-to-buffer (buffer start end)
  "Introduce al búffer específico el texto de la
  región. Esto es insertado de este búffer antes de su punto.

Cuando se llama desde un programa, se dan tres argumentos:
BUFFER (o nombre del búffer), START y END.
START y END especifica la porción del búffer actual para ser copiado."
  (interactive
   (list (read-buffer "Append to buffer: " (other-buffer
                                            (current-buffer) t))
         (region-beginning) (region-end)))

  (let ((oldbuf (current-buffer)))
    (save-excursion
      (let* ((append-to (get-buffer-create buffer))
             (windows (get-buffer-window-list append-to t t))
             point)
        (set-buffer append-to)
        (setq point (point))
        (barf-if-buffer-read-only)
        (insert-buffer-substring oldbuf start end)
        (dolist (window windows)
          (when (= (window-point window) point)
            (set-window-point window (point))))))))




La función puede ser comprendida buscando como series de plantillas
rellenas



La plantilla de fuera es para la definición de la función. En esta
función, se ve como esto (con varios slots rellenos):



 
(defun append-to-buffer (buffer start end)
  "documentation…"
  (interactive …)
  body…)




La primera línea de la función incluye su nombre y los
tres argumentos. Los argumentos son el búffer que el texto
será copiado, y el start y end de la región en el
buffer actual que será copiado.



La siguiente parte de la función es la documentación, que es claro
y completo. Como es convencional, los tres argumentos son escritos en
mayúsculas así se notificarán fácilmente. Incluso
mejor, son descritas en el mismo orden como en la lista de argumentos.



Nótese que la documentación distingue entre un búffer y su
nombre. (La función puede manejar otro.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.4.1 La Expresión Interactiva append-to-buffer



Desde que la función append-to-buffer será usada
interactivamente, la función debe tener una expresión
interactive. (Para una revisión de interactive, ver
Creando una Función Interactive.) La
expresión se lee de la siguiente manera:



 
(interactive
 (list (read-buffer
        "Agrega al buffer: "
        (other-buffer (current-buffer) t))
       (region-beginning)
       (region-end)))




Esta expresión no es una con letras separadas por partes, como se
describe antes. En vez de eso, empieza una lista con estas partes:



La primera parte de la lista es una expresión para leer el nombre de
un búffer y lo devuelve como una cadena. Esto es
read-buffer. La función requiere una consola como su primer
argumento, ‘"Asocia al buffer: "’. Su segundo argumento cuenta el
comando que valora para proporciona si no especifica cualquier cosa.



En este caso este segundo argumento es una expresión conteniendo la
función other-buffer, una excepción, y una ‘t’, para verdad.



El primer argumento para other-buffer, la excepción, es
todavía otra función, other-buffer. Esto es no
yendo a ser devuelto. El segundo argumento es el símbolo
para verdad, t. Esto cuenta other-buffer que puede
mostrar búffers visibles (excepto en este caso, eso no mostrará el
búffer actual, que tiene sentido).



La expresión se ve como:



 
(other-buffer (current-buffer) t)




El segundo y tercer argumento a la expresión list son
(region-beginning) y (region-end). Estas dos funciones
especifican el principio el y el fin del texto para ser adjunto.



Originalmente, el comando usaba las letras ‘B’ y ‘r’. La
expresión completa interactive es así:



 
(interactive "BAsociar al buffer: \nr")




Pero cuando esto fué hecho, el valor por defecto del búffer cambió
a ser invisible. Esto no se quería.



(La consola era separada del segundo argumento con una nueva
línea, ‘\n’. Estaba seguido por un ‘r’ que
contaba a Emacs emparejar los dos argumentos que siguen el
símbolo buffer en la lista de argumentos de la
función (que es, start y end) para los valores de
punto y marca. Este argumento trabajó bien.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.4.2 El Cuerpo de append-to-buffer




El cuerpo de la función append-to-buffer empieza con let.



Como se ha visto antes (véase la sección let), el propósito de
una expresión let es crear y dar valores iniciales a una o
más variable que solo serán usada con el cuerpo del
let. Esto significa que tal variable no será confuso con
cualquier variable del mismo nombre fuera de la expresión let.



Podemos ver como la expresión let se ajusta dentro de la
función como un todo mostrando una plantilla para
append-to-buffer con la expresión let en
línea:



 
(defun append-to-buffer (buffer start end)
  "documentation…"
  (interactive …)
  (let ((variable value))
        body…)




La expresión let tiene tres elementos:



    

  1. 
El símbolo let;


  2. 
Una varlist conteniendo, en este caso, una lista simple de dos
elementos, (variable value);


  3. 
El cuerpo de la expresión let.




En la función append-to-buffer, la varlist se parece a esto:



 
(oldbuf (current-buffer))




En esta parte de la expresión let, una variable,
oldbuf es emparejada al valor devuelto por la expresión
(current-buffer). La variable, oldbuf, es usada para
guardar la traza del búffer en el que tu estás trabajando y desde
el que se copiará.



El elemento o elementos de una varlist son rodeados por un conjunto de
paréntesis así el intérprete Lisp puede distinguir
la varlist desde el cuerpo del let. Como consecuencia, la lista
de dos elementos con la varlist está rodeados por un circunscrito
conjunto de paréntesis. Las líneas se ven
así:



 
(let ((oldbuf (current-buffer)))
  … )




Los dos paréntesis antes de oldbuf podrían
sorprenderte si no fuera porque los primeros paréntesis antes de
oldbuf marcan el límite de la varlist y el segundo
paréntesis marca el principio de la lista de dos elementos,
(oldbuf (current-buffer)).








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.4.3 save-excursion en append-to-buffer



El cuerpo de la expresión let en append-to-buffer
consiste de una expresión save-excursion.



La función save-excursion guarda las localizaciones de punto y
la marca, y las restaura a estas posiciones después de las expresiones
en el cuerpo de la ejecución completa
save-excursion. Además, save-excursion completa
la ejecución. Además, save-excurion guarda la traza del
búffer original, y lo restaura. Esto es cómo save-excursion
es usado en append-to-buffer.





Incidentalmente, no se valora nada aquí que una
función Lisp es normalmente formateada así que cada
cosa que es encerrada en conjunto multilínea que es
indentada más a la derecha que el primer símbolo. En
esta definición de función, el let es indentado más que
defun, y el save-excursion es indentado más que el
let, como esto:



 
(defun …
  …
  …
  (let…
    (save-excursion
      …




Esta convención formatea que sea fácil de ver que las
líneas en el cuerpo de save-excursion, solo
como save-excurion por sí mismo están
encerradas por los paréntesis asociados con el let:



 
(let ((oldbuf (current-buffer)))
  (save-excursion
    …
    (set-buffer …)
    (insert-buffer-substring oldbuf start end)
    …))




El uso de la función save-excursion puede ser vista como un
proceso de rellenar slots de una plantilla:



 
(save-excursion
  first-expression-in-body
  second-expression-in-body
   …
  last-expression-in-body)




En esta función, el cuerpo de save-excursion contiene solo
una expresión, la expresión let*. Se conoce una función
let. La función let* es diferente. Eso tiene un
‘*’ en su nombre. Eso permite a Emacs asignar cada variable en su
varlist en secuencia, uno después de otro.



Su funcionalidad crítica es que las variable después
en la varlist puedan hacer uso de los valores para los que Emacs asigna
variables pronto en la varlist. Véase la sección  La expresión let*.



Se escaparán funciones como let* y focaliza en dos: la
función set-buffer y la función insert-buffer-substring.



En antaño, la expresión set-buffer era simple:



 
(set-buffer (get-buffer-create buffer))




pero ahora eso es



 
(set-buffer append-to)




append-to se asigna a (get-buffer-create-buffer) pronto
en la expresión let*. Esta asociación extra no
sería necesaria excepto para este append-to es
usado después en la varlist como un argumento para
get-buffer-window-list.




La definición de la función append-to-buffer inserta texto
desde el búffer en el que estás actualmente a un buffer
nombrado. Eso sucede que insert-buffer-substring copia texto
desde otro búffer al búffer actual, solo el inverso --- que es
porque la definición append-to-buffer empieza con un
let que asocia el símbolo local oldbuf al
valor devuelto por current-buffer.



La expresión insert-buffer-substring se ve como esto:



 
(insert-buffer-substring oldbuf start end)




La función insert-buffer-substring copia una cadena
from al búffer especificado como su primer argumento e
inserta la cadena dentro del búffer presente. En este caso, el
argumento para insert-buffer-substring es el valor de la
variable creada y asociada por el let, llama al valor de
oldbuf, que fué el búffer actual cuando tu diste el comando
append-to-buffer.



Después de que insert-buffer-substring ha hecho su trabajo,
save-excursion restaurará la acción al búffer original y
append-to-buffer habrá hecho su trabajo.



Escrito en forma esquelética, los trabajos del cuerpo se ven como esto:



 
(let (bind-oldbuf-to-value-of-current-buffer)
  (save-excursion                       ; Guarda la traza del búffer.
    change-buffer
    insert-substring-from-oldbuf-into-buffer)

  change-back-to-original-buffer-when-finished
let-the-local-meaning-of-oldbuf-disappear-when-finished




En resumen, append-to-buffer funciona como sigue: guarda el
valor del buffer actual en la variable llamada oldbuf. Obtiene
el nuevo buffer (creando uno si necesita ser) y cambia la atención
de Emacs a eso. Usando el valor de oldbuf, inserta la región
del texto desde el viejo buffer dentro del nuevo buffer; y entonces
usando save-excursion, trae atrás a tu buffer original.



Buscando append-to-buffer, se ha explorado una función limpia
compleja. Eso muestra como usar let y save-excursion, y
como cambiar y volver desde otro buffer. Muchas definiciones de
función usan let, save-excursion, y set-buffer
de este modo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.5 Revisar



Aquí está un breve resumen de varias funciones
discutidas en este capítulo.





 describe-function


 describe-variable


Imprime la documentación para una función o
variable. Convencionalmente asociada a C-h f y C-h v.





 find-tag


Encuentra el fichero que contiene la fuente para una función o
variable y cambia buffer a él, posicionando el punto al principio
del ítem. Convencionalmente emparejado a M-. (esto
es un período seguiendo la tecla <META>).





 save-excursion


Guarda la localización de punto y marca y restaura sus valores
después de los argumentos para save-excursion y han sido
evaluados. También, recuerda el buffer actual y devuélvelo.





 push-mark


Asigna la marca en una localización y graba el valor de la marca
previa en el anillo de la marca. La marca es una localización en el
búffer que guarda su posición relativa incluso si el texto es
añadido o borrado desde el búffer.





 goto-char


Asigna punto a la localización especificada por el valor del
argumento, que puede ser un número, una marca, o una expresión que
devuelve el número de una posición, tal como (point-min).





 insert-buffer-substring


Copia una región de texto desde un búffer que es pasado a la
función como un argumento e inserta la región dentro del búffer
actual.





 mark-whole-buffer


Marca el búffer completo como una región. Normalmente asignado a
C-x h.





 set-buffer


Cambia la atención de Emacs a otro búffer, pero no cambies la
ventana siendo mostrada. Usado cuando el programa en vez de un humano
trabaja en un búffer diferente.





 get-buffer-create


 get-buffer


Encuentra un buffer nombrado o crea uno si un buffer de este nombre no
existe. La función get-buffer devuelve nil si el
nombre del búffer no existe.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




4.6 Ejercicios










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5. Unas Pocas Funciones Más Complejas



En este capítulo, se construye lo que se aprendió en
los capítulos previos mirando en funciones más
complejas. La función copy-to-buffer ilustra el uso de
expresiones save-excursion en una definición, mientras la
función insert-buffer ilustra el uso de un asterisco en una
expresión interactive, uso de o, y la importante
distinción entre un nombre y el objeto para el que el nombre se
refiere.





5.1 La Definición de copy-to-buffer             Con set-buffer, 
                               get-buffer-create.



5.2 La Definición de insert-buffer              Solo lectura, y con or.



5.3 Definición Completa de beginning-of-buffer        Muestra goto-char, point-min, y 
                               push-mark.
* Revisión Segundo Búffer Relacionado



5.5 Ejercicio de Argumento opcional         











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.1 La Definición de copy-to-buffer




Después de comprender cómo se trabaja append-to-buffer, es
fácil para comprender copy-to-buffer. Esta función copia
texto dentro de un búffer, pero en vez de añadir al segundo
búffer, se reemplaza a todo el texto previo en el segundo búffer.



El cuerpo de copy-to-buffer se ve como esto,



 
…
(interactive "BCopy to buffer: \nr")
(let ((oldbuf (current-buffer)))
  (with-current-buffer (get-buffer-create buffer)
    (barf-if-buffer-read-only)
    (erase-buffer)
    (save-excursion
      (insert-buffer-substring oldbuf start end)))))




La función copy-to-buffer tiene una expresión simple
interactive en vez de append-to-buffer.



La definición entonces dice:



 
(with-current-buffer (get-buffer-create buffer) …




Primero, mira en la expresión interna más temprana; que es
evaluada primero. Esta expresión empieza con get-buffer-create
buffer. La función cuenta al ordenador para usar el búffer con el
nombre específicado como uno para el que estás
copiando, o si tal búffer no existe, créalo. Entonces, la función
with-current-buffer evalúa su cuerpo con este búffer
temporalmente al actual.



(Esto demuestra otro camino para cambiar la atención del ordenador
pero no los usuarios. La función append-to-buffer muestra
como hacer lo mismo con save-excursion y
set-buffer. with-current-buffer es uno nuevo, y
argumentablemente fácil, mecanismo.)



La función barf-if-buffer-read-only envía un
mensaje de error diciendo al búffer es de solo lectura si no se
puede modificar.



La siguiente línea tiene la función
erase-buffer como sus únicos contenidos. Este función borra
el búffer.



Finalmente, las últimas dos líneas contienen la
expresión save-excursion con insert-buffer-substring
como su cuerpo. La expresión insert-buffer-substring copia el
texto desde el búffer en el que estás (y no se ha visto el
ordenador puesta su atención, así no se sabe que este
búffer es ahora llamado oldbuf).



De manera incidental, esto es lo que significa por `reemplazo'. Para
reemplazar texto Emacs borra el texto previo y entonces inserta el
nuevo texto.



El código fuente, del cuerpo de copy-to-buffer se parece a
esto:



 
(let (bind-oldbuf-to-value-of-current-buffer)
    (with-the-buffer-you-are-copying-to
      (but-do-not-erase-or-copy-to-a-read-only-buffer)
      (erase-buffer)
      (save-excursion
        insert-substring-from-oldbuf-into-buffer)))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2 La Definición de insert-buffer




insert-buffer es todavía una función
relacionada con el búffer. Este comando copia otro búffer
dentro del búffer actual. Es lo inverso de
append-to-buffer o copy-to-buffer, desde que se copia
una región de texto desde el búffer actual a otro
búffer.



Aquí hay una discusión basada en el código
original. El código era simplificado en 2003 y es duro de comprender.



(Véase la sección  Nuevo Cuerpo para insert-buffer,
para ver una discusión del nuevo cuerpo.)



Además, este código ilustra el uso de interactive con un
búffer que podría ser read-only y la
distinción entre el nombre de un objeto y el objeto actualmente referido.





• código insert-buffer  



5.2.1 La Expresión Interactiva en insert-buffer    Cuando tu puedes leer, pero no escribir.



5.2.2 El Cuerpo de la Función insert-buffer       El cuerpo tiene un or y un let.



5.2.3 insert-buffer Con un if En vez de un or                     Usando un if en vez de un or.



5.2.4 El or en el Cuerpo                Cómo la expresión or funciona.



5.2.5 La Expresión let en insert-buffer               Dos expresiones save-excursion.



5.2.6 Nuevo Cuerpo para insert-buffer        











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




El Código para insert-buffer



Aquí está el primer código



 
(defun insert-buffer (buffer)
  "Inserta después del punto los contenidos del BUFFER.
Pon la marca después del texto insertado.
El BUFFER puede ser un buffer un nombre de buffer."
  (interactive "*bInsert buffer: ")

  (or (bufferp buffer)
      (setq buffer (get-buffer buffer)))
  (let (start end newmark)
    (save-excursion
      (save-excursion
        (set-buffer buffer)
        (setq start (point-min) end (point-max)))

      (insert-buffer-substring buffer start end)
      (setq newmark (point)))
    (push-mark newmark)))




Como con otras definiciones de función, se puede usar una plantilla
para visión de la función:



 
(defun insert-buffer (buffer)
  "documentation…"
  (interactive "*bInsert buffer: ")
  body…)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2.1 La Expresión Interactiva en insert-buffer




En insert-buffer, el argumetno para la declaración
interactive tiene dos partes, un asterisco, ‘*’, y
‘bInserta un buffer: ’.





Un Búffer de Solo lectura        Cuando un buffer no puede ser modificado.



‘b’ es una Expresión Interactiva         Un buffer existe o además su nombre.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Un Búffer de Solo lectura






El asterisco es para la situación cuando el buffer actual es un
buffer de solo lectura --- un buffer que no puede ser modificado. Si
insert-buffer es llamado cuando el buffer actual es de solo
lectura, un mensaje a este efecto está impreso en el área echo y
el terminal puede avisar; no se permite insertar cualquier cosa dentro
del buffer. El asterisco no necesita ser seguido por una nueva
línea para separarse desde el siguiente argumento.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




‘b’ es una Expresión Interactiva



El siguiente argumento en la expresión interactiva empieza con una
tecla minúscula ‘b’. (Esto es diferente desde el código para
append-to-buffer, que usa una mayúscula
‘B’. Véase la sección  La Definición de append-to-buffer.) La tecla minúscula cuenta al intérprete
Lisp que el argumento para insert-buffer sería un
buffer existente o sino su nombre. (La mayúscula ‘B’ provee
para la posibilidad que el búffer no existe.) Emacs te mostrará en
pantalla el nombre del búffer, ofreciendo un búffer por defecto,
con la compleción de nombre habilitado. Si el búffer no existe, se
recibe un mensaje que dice ``No concuerda''; tu terminal te avisa también.



El nuevo y simplificado código genera una lista
interactive. Eso usa las funciones
barf-if-buffer-read-only y read-buffer con las que
estamos ya familiarizados y la forma especial progn con los que
no. (Eso será descrito después).








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2.2 El Cuerpo de la Función insert-buffer



El cuerpo de la función insert-buffer tiene dos partes
principales: una expresión or y una expresión
let. El propósito de la expresión or es asegura que
el argumento buffer es emparejado a un buffer y no solo el
nombre de un buffer. El cuerpo de la expresión let contiene
el código que copia los otros buffer dentro del buffer.



En el "outline" (esquema), las dos expresiones se ajustan dentro de la
función insert-buffer como esto:



 
(defun insert-buffer (buffer)
  "documentation…"
  (interactive "*bInsertar buffer: ")
  (or …
      …

  (let (varlist)
      body-of-let… )




Para comprender como la expresión or asegura que el argumento
buffer es emparejado a un buffer y no al nombre de un búffer,
es primero necesario comprender la función or.



Antes de hacer esto, permíteme reescribir esta parte de
la función usando if así puedes ver que es
hecho en una manera que será familiar.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2.3 insert-buffer Con un if En vez de un or



El trabajo que debe ser hecho y asegura el valor de búffer es
un buffer en sí mismo y no el nombre de un búffer. Si
el valor es el nombre, entonces el buffer en sí debe ser
obtenido.



Te puedes imaginar a tí mismo en una conferencia donde
un acomodador está observando una lista con tu nombre dentro y
mirándote: el acomodador sabe ``asociar'' tu nombre, pero no a
tí; pero cuando el acomodador te encuentra y te toma el
brazo, el acomodador llega a ``asociarte'' a tí.



En Lisp, se podría describir esta situación
así:



 
(if (not (holding-on-to-guest))
    (find-and-take-arm-of-guest))




Se quiere hacer la misma cosa con un búffer --- si no tenemos el
búffer en sí, queremos tenerlo.



Usando un predicado llamado bufferp que nos cuenta si tenemos
un búffer (en vez de su nombre), se puede escribir el código como
este:



 
(if (not (bufferp buffer))              ; if-part
    (setq buffer (get-buffer buffer)))  ; then-part




Aquí, el true-or-false-test de la expresión if
es @w((not (bufferp buffer))); y la then-part es la expresión
(setq buffer (get-buffer buffer)).



En el test, la función bufferp devuelve cierto si su
argumento es un búffer --- pero falso si su argumento es el nombre del
buffer. (El último carácter del nombre de la función
bufferp es el carácter ‘p’; como se vió antes, tal uso de
‘p’ es una convención que indica que la función es un
predicado, que es un término que significa que la función
determinará si alguna propiedad es verdadera o falsa. Véase la sección  Usando el Objeto de Tipo Incorrecto como un Argumento.)



La función not precede la expresión (bufferp
buffer), así el true-or-false-test se ve como esto:



 
(not (bufferp buffer))




no es una fución que devuelve cierto si su argumento es falso
y falso si su argumento es verdadero. Así si
(bufferp buffer) devuelve cierto, la expresión no
devuelve falso y vice-versa: que es ``no cierto'' es falso que es ``no
falso'' es verdadero.



Usando este test, la expresión if trabaja como sigue: cuando
el valor de la variable buffer está actualmente en un
búffer en vez de su nombre, el test true-or-false-test devuelve
false y la expresión if no evalúa la parte then-part. Esto
está bien, desde que no necesita para hacer cualquier cosa para la
variable buffer si es realmente un búffer.



Por otro lado, cuando el valor de buffer no es un buffer en
sí, pero el nombre de un buffer, el true-or-false-test
devuelve cierto y la then-part de la expresión es evaluada. En este
caso, la then-part es (setq buffer (get-buffer buffer)). Esta
expresión usa la función get-buffer para devolver un buffer
actual en sí, dado su nombre. El setq entonces
asigna la variable buffer al valor del buffer en
sí, reemplazando su valor previo (que era el nombre del
buffer).








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2.4 El or en el Cuerpo



El propósito de la expresión or en la función
insert-buffer es asegurar que el argumento buffer está
asociado a un búffer y no solo al nombre de un búffer. La sección
previa muestra como el trabajo podría haber sido hecho
usando una expresión if. Sin embargo, la función
insert-buffer actualmente usa or. Para comprender este,
es necesario comprender como or trabaja.




Una función or puede tener cualquier número de
argumentos. Eso evalúa cada argumento en turno y devuelve el valor
del primero de sus argumentos que no es nil. También, y esto
es una funcionalidad crucial de or, eso no evalúa cualquier
argumentos subsiguientes después devolviendo el primer valor
no-nil.



La expresión or se ve como esto:



 
(or (bufferp buffer)
    (setq buffer (get-buffer buffer)))




El primer argumento a or es la expresión (bufferp
buffer). Esta expresión devuelve cierto (un valor no-nil) si
el buffer es actualmente un buffer, y no solo el nombre de un
buffer. En la expresión or, si este es el caso, la
expresión or devuelve esto el valor cierto y no evalúa la
siguiente expresión --- y esto es bueno para nosotros, desde que
nosotros no queremos hacer cualquier cosa al valor de buffer si
eso es realmente un buffer.



Por otro lado, si el valor de (bufferp buffer) es nil,
que será si el valor de buffer es el nombre de un buffer, el
intérprete Lisp evalúa el siguiente elemento de la
expresión. Esta es la expresión (setq buffer (get-buffer
buffer)). Esta expresión devuelve un valor no-nil, que es el
valor para el que asigna la variable buffer --- y este valor es
un búffer en sí, no el nombre de un búffer.



El resultado de todo esto es que el símbolo
buffer es siempre asociado a un búffer en sí en
vez del nombre de un búffer. Toda es necesario porque la función
set-buffer en una línea siguiente trabaja con un
buffer en sí, no con el nombre de un búffer.



Incidentalmente, usando or, la situación con el acomodador se
vería así:



 
(or (holding-on-to-guest) (find-and-take-arm-of-guest))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2.5 La Expresión let en insert-buffer



Después asegurando que la variable buffer se refiere a un
buffer en sí y no solo al nombre de un buffer, la
función insert-buffer continúa con una expresión
let. Esto especifica tres variables locales, start,
end y newmark y los asocia al valor inicial
nil. Estas variables son usadas dentro el recuerdo de
let y temporalmente oculto con cualquier otra ocurrencia de
variables del mismo nombre en Emacs hasta el fin del let.



El cuerpo del let contiene dos expresiones
save-excursion. Primero, miraremos la expresión
save-excursion en detalle. La expresión se parece a esto:



 
(save-excursion
  (set-buffer buffer)
  (setq start (point-min) end (point-max)))




La expresión (set-buffer buffer) cambia la atención de
Emacs desde el búffer actual a uno desde el que el texto será
copiado. En este búffer la variables start y end son
asignadas al principio y fin del búffer, usando los comandos
point-min y point-max. Note que tenemos
aquí una ilustración de como setq es capaz de
asignar dos variables en la misma expresión. El primer argumento de
setq es asignar al valor de su segundo, y su tercer argumento
está asignado al valor del cuarto.



Después el cuerpo del save-excursion propio es evaluado, el
save-excursion restaura el búffer original, pero start
y end permanece asignado a los valores del principio y fin del
búffer de el que el texto será copiado.



La expresión por fuera save-excursion] se ve como:



 
(save-excursion
  (inner-save-excursion-expression
     (go-to-new-buffer-and-set-start-and-end)
  (insert-buffer-substring buffer start end)
  (setq newmark (point)))




La función insert-buffer-substring copia el texto
dento del búffer desde la región indicada por
start y end en el búffer. Desde el total del
segundo búffer cae entre start y end, el todo del
segundo búffer es copiado dentro del búffer que estás
editando. Lo siguiente, el valor del punto, que será al fin del
texto insertado, es grabado en la variable newmark.



Después el cuerpo de save-excursion es evaluado, punto y
marca son recolocados a sus lugares originales.



Sin embargo, es conveniente localizar una marca al fin del texto
nuevamente insertado y localizar el punto al principio. La variable
newmark graba el fin del texto insertado. En la última
línea de la expresión let, la expresión de la
función (push-mark newmark) asigna una marca a esta
posición. (La posición previa de la marca está
todavía accesible; está grabado en la marca del anillo
y se puede regresar a eso con C-u C-<SPC>.) Mientras tanto,
el punto está localizado al principio del texto insertado, que
está donde estaba antes de ser llamado la función que inserta, la
posición de lo que estaba guardado por la primera save-excursion.



La expresión let se parece a esto:



 
(let (start end newmark)
  (save-excursion
    (save-excursion
      (set-buffer buffer)
      (setq start (point-min) end (point-max)))
    (insert-buffer-substring buffer start end)
    (setq newmark (point)))
  (push-mark newmark))




Como la función append-to-buffer, la función
insert-buffer usa let, save-excursion y
set-buffer. Además, la función ilustra un camino para usar
o. Toda estas funciones están construyendo bloque que
encontrarán y usarán una y otra vez.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.2.6 Nuevo Cuerpo para insert-buffer





El cuerpo en la versión de GNU Emacs 22 es más confuso que en el
original.



Consiste de dos expresiones



 
  (push-mark
   (save-excursion
     (insert-buffer-substring (get-buffer buffer))
     (point)))

   nil




excepto, y esto es lo que los novicios confunden, un trabajo muy
importantes es hecho dentro de la expresión push-mark.



La función get-buffer devuelve un buffer con el nombre
proporcionado. Tu tomarás nota de que la función no es
llamado get-buffer-create; eso no crea un búffer si uno no
existe ya. El búffer devuelto por get-buffer, un búffer
existente, es pasado a insert-buffer-substring, que inserta el
total del búffer (desde que no se especificón ninguna cosa
más).



La posición dentro del buffer es insertado es grabado por
push-mark. Entonces la función devuelve nil, el valor
de su último comando. Pon otro camino, la función
insert-buffer existe solo para producir un efecto lateral,
insertando otro buffer, no para devolver cualquier valor.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.3 Definición Completa de beginning-of-buffer




La estructura básica de la función beginning-of-buffer ya
ha sido discutida. (Véase la sección  Una Definición Simplificada beginning-of-buffer). Esta sección
describe la parte compleja de la definición.



Como se describe previamente, cuando se invoca sin un argumento,
beginning-of-buffer mueve el cursor al principio del búffer
(en realidad, al principio de la porción accesible del búffer),
dejando la marca en la posición previa. Sin embargo, cuando el
comando es invocado con un número entre uno y diez, la función
considera que número será una fracción del tamaño del
búffer, medido en decenas, y Emacs mueve el cursor en esta
fracción del camino desde el principio del búffer. De este modo,
se puede bien llamar a esta función con la tecla comando M-<,
que moverá el cursor al principio del búffer, o con una tecla tal
como C-u 7 M-< que moverá el cursor a un punto 70% del camino
a través del búffer. Si un número más grande que diez es usado
para el argumento se mueve al fin del búffer.



La función beginning-of-buffer puede ser llamado con o sin
argumentos. El uso del argumento es opcional.





5.3.1 Argumentos Opcionales  



5.3.2 beginning-of-buffer con un Argumento    Ejemplo con argumento opcional.



5.3.3 El beginning-of-buffer Completo    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.3.1 Argumentos Opcionales



A menos que se cuente de otro modo, Lisp espera que una función con
un argumento en su definición de función se llame con un valor
para este argumento. Si esto no ocurre, se obtiene un error y un
mensaje que dice ‘Número de argumentos erróneo’.






Sin embargo, los argumentos opcionales son una funcionalidad de Lisp:
una palabra clave particular es usada para contar al
intérprete Lisp que un argumento es opcional. La palabra clave es
&optional. (El ‘&’ en frente de ‘opcional’ es parte
de la palabra clave.) En una definición de función, si un
argumento sigue a la palabra clave &optional, ningún valor
necesita ser pasado a este argumento cuando la función se llama.



La primera línea de la definición de función de
beginning-of-buffer tiene lo siguiente:



 
(defun beginning-of-buffer (&optional arg)




En el "outline" (esquema), la función completa se parece a esto:



 
(defun beginning-of-buffer (&optional arg)
  "documentation…"
  (interactive "P")
  (or (is-the-argument-a-cons-cell arg)
      (and are-both-transient-mark-mode-and-mark-active-true)
      (push-mark))
  (let (determine-size-and-set-it)
  (goto-char
    (if-there-is-an-argument
        figure-out-where-to-go
      else-go-to
      (point-min))))
   do-nicety




La función es similar a la función
simplified-beginning-of-buffer excepto que la expresión
interactive tiene "P" como un argumento y la función
goto-char es seguida por una expresión if-then-else que
figura donde poner el cursor si hay un argumento que no es un cons cell.



(Puesto que no se explica un cons cell en muchos
capítulos, por favor, considere ignorar la función
consp. Como las Listas son Implementadas, y (elisp)Tipo de Cons Cell sección `Cons Cell y Tipos de Listas' en El Manual de Referencia GNU Emacs Lisp).



El "P" en la expresión interactive cuenta a Emacs
cómo pasar un argumento prefijo, si hay uno, a la función en forma
plana. Un argumento prefijo se crea escribiendo la tecla <META>
seguida por un número, o escribiendo C-u y entonces un
número. (Si no escribes un número, C-u por defecto a un cons
cell con un 4. Una minúscula "p" en la expresión
interactive causa a la función convertir un argumento prefijo
a un número.)



El true-or-false-test de la expresión if se ve compleja, pero
no lo es: se chequea si arg tiene un valor que no es nil
y si es un cons cell. (Esto es lo que consp hace; chequea si su
argumento es un cons cell.) Si arg tiene un valor que no es
nil (y no es un cons cell.), que será el caso si
beginning-of-buffer se llama con un argumento, entonces este
true-or-false-test devolverá cierto y la then-part de la expresión
if falsa. Por otro lado, si beginning-of-bufer no se
llama con un argumento, el valor de arg será nil y la
else-part de la expresión if se evaluará. La else-part es
simple point-min, y esto es lo de fuera, la expresión
goto-char es (goto-char (point-min)), que es como se
vió la función beginning-of-buffer en su forma
simplificada.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.3.2 beginning-of-buffer con un Argumento



Cuando beginning-of-buffer se llama con un argumento, una
expresión es evaluada que calcula que valor pasa a
goto-char. Esto es incluso complicado a primera vista. Eso
incluye una expresión if propia y mucha aritmética. Se ve
así:



 
(if (> (buffer-size) 10000)
    ;; ¡Evitar sobrecarga para grandes tamaños de búffer!
                          (* (prefix-numeric-value arg)
                             (/ size 10))
  (/
   (+ 10
      (*
       size (prefix-numeric-value arg))) 10)))






• Rompe la obstrucción de beginning-of-buffer  



Qué ocurre en búffer largo  



Qué ocurre en un búffer pequeño    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Desenmarañar beginning-of-buffer



Como otras expresiones que se ven complejas, la expresión
condicional con beginning-of-buffer puede ser desenredada
mirándola por partes de una plantilla, en este caso, la plantilla
par una expresión if-then-else. En forma esquelética, la
expresión se ve así:



 
(if (buffer-is-large
    divide-buffer-size-by-10-and-multiply-by-arg
  else-use-alternate-calculation




El true-or-fase-test de esta expresión if propia chequea el
tamaño del buffer. La razón para esto es que la versión vieja de
Emacs 18 usaba números que no son más grandes que 8 millones o
así y en la computación que seguía, el
programador temía que Emacs podría
intentar usar a través de largos números si el búffer fuera
largo. El término `sobrecarga', que se mencionó en el comentario,
significa que los números son grandes. Las versiones más recientes
de Emacs usan números largos, pero este código no ha sido tocado,
solo porque la gente ahora mira en búffers que están lejos, tan
lejos como antes.



Hay dos casos: si el búffer es largo, o si no.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Qué ocurre en búffer largo



En beginning-of-buffer, la expresión propia if chequea
si el tamaño del búffer es mayor que 10000 caracteres. Para hacer
esto, se usa la función > y la computación de size
que viene desde la expresión let.



Hace tiempo, se usaba la función buffer-size. No solo esta
función era llamada varias veces, eso daba el tamaño del búffer
completo, no la parte accesible. La computación tiene mucho más
sentido cuando se maneja solo la parte accesible. (Véase la sección  Extendiendo y Encogiendo, para más información en
focalizar la atención para una parte `accesible'.)



La línea se parece a esto:



 
(if (> size 10000)




Cuando el búffer es largo, el then-part de la expresión if
se evalúa. Eso se lee así (después de ser formateado
para una fácil lectura):



 
(*
  (prefix-numeric-value arg)
  (/ size 10))




Esta expresión es una multiplicación, con dos argumentos para la
función *.



El primer argumento es (prefix-numeric-value arg). Cuando
"P" se usa como argumento para interactive, el valor
pasado para la función como argumento es un ``argumento prefijo
crudo'', y no un número. (Es un número en una lista). Para
desarrollar la aritmética, una conversión es necesaria, y
prefix-numeric-value hace el trabajo.





El segundo argumento es (/ size 10). Esta expresión divide el
valor numérico por diez --- el valor numérico del tamaño de la
porción accesible del buffer. Esto produce un número que cuenta
cuantos caracteres crean una decena del tamaño del búffer. (En Lisp,
/ es usado para división, solo como * es usado para
multiplicación.)



En la expresión de la multiplicación como un todo, esta cantidad
se multiplica por el valor del argumento prefijo --- la
multiplicación se parece a:



 
(* numeric-value-of-prefix-arg
   number-of-characters-in-one-tenth-of-the-accessible-buffer)




Si, por ejemplo, el argumento prefijo es ‘7’, el valor one-tenth
será multiplicado por 7 para dar una posición del 70% del camino.



El resultado de todo esto es que si la porción accesible del búffer
es largo, la expresión goto-char se lee esto:



 
(goto-char (* (prefix-numeric-value arg)
              (/ size 10)))




Esto pone el cursor donde se quiere.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Qué ocurre en un búffer pequeño



Si el búffer contiene poco más de 10000 caracteres, una
computación ligeramente diferente es medida. Se podría
pensar que esto no es necesario, desde que la primera computación
podría hacer el trabajo. Sin embargo, en un búffer
pequeño, el primer método puede no poner el cursor en la
línea exactamente deseada; el segundo método hace un
trabajo mejor.



El código se parece a esto:



 
(/ (+ 10 (* size (prefix-numeric-value arg))) 10))




Este es el código en el que se ve qué ocurre descubriendo como las
funciones se embeben entre paréntesis. Eso es fácil de leer si se
reformatea con cada expresión indentada más profundamente que la
expresión que encierra:



 
  (/
   (+ 10
      (*
       size
       (prefix-numeric-value arg)))
   10))




Mirando los paréntesis, se ve que la operación propia es
(prefix-numeric-value arg), que convierte el argumento plano
para un número. En la siguiente expresión, este número es
multiplicado por el tamaño de la porción accesible del búffer:



 
(* size (prefix-numeric-value arg))




Esta multiplicación crea un número que puede ser más largo que
el tamaño del buffer --- siete veces más larga si el argumento es
7, por ejemplo. Diez se aãnade a éste nũmero y finalmente el
número es dividido por 10 para proporcionar un valor que es un
carácter más largo que la posición de porcentaje en el búffer.



El número que resulta de todo esto se pasa a goto-char y
el cursor se mueve a este punto.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.3.3 El beginning-of-buffer Completo



Aquí está el texto completo de la función
beginning-of-buffer:





 
(defun beginning-of-buffer (&optional arg)
  "Mueve el punto al principio del buffer;
deja marca en la posición previa. 
Con prefijo \\[universal-argument], 
no se asigna una marca en la posición previa.
Con el argumento numérico N, pon el 
punto N/10 del camino desde el principio.Si el búffer está encogido
este comando usa el principio y tamaño
de la parte accesible del búffer.


"No use este comando en programas Lisp 
\(goto-char (point-min)) es rápido
y evita poseer la marca."
  (interactive "P")
  (or (consp arg)
      (and transient-mark-mode mark-active)
      (push-mark))

  (let ((size (- (point-max) (point-min))))
    (goto-char (if (and arg (not (consp arg)))
                   (+ (point-min)
                      (if (> size 10000)
                          ;; Evita sobrecarga para tamaños de búffer
                          (* (prefix-numeric-value arg)
                             (/ size 10))
                        (/ (+ 10 (* size (prefix-numeric-value arg)))
                           10)))
                 (point-min))))
  (if arg (forward-line 1)))





Excepto por dos pequeños puntos, la discusión previa muestra
cómo esta función trabaja. El primer punto trata un detalle en la
cadena de documentación, y el segundo concierne la última
línea de la función.



En la cadena de documentación, hay referencia a una expresión:



 
\\[universal-argument]




Un ‘\\’ es usado antes de la primera llave de esta
expresión. Este ‘\\’ le cuenta al intérprete Lisp sustituir
qué clave está actualmente emparejada a los ‘[…]’. En el
caso de universal-argument, que es normalmente C-u, pero
eso podría ser diferente. (Véase (elisp)Consejos de Documentación sección `Consejos para Cadenas de Documentación' en El Manual de Referencia de GNU Emacs Lisp, para más información.)



Finalmente, la última línea del comando
beginning-of-buffer dice mover el punto al principio de la
siguiente línea si el comando es invocado con un argumento:



 
(if arg (forward-line 1)))




Esto pone el cursor al principio de la primera línea
después de las apropiadas decenas de posiciones en el búffer. Esto
significa que el cursor está siempre localizado al menos las
decenas solicitadas del camino a través del búffer, que es un bien
que es, quizás, no necesario, pero que, si no ocurrió,
estaría seguro de dibujar rumores.



Por otro lado, eso significa que si se especifica el comando con un
C-u, sin un número, que es decir, si el `prefijo de argumento
plano' es simplemente un cons cell, entonces el comando te pone al
principio de la segunda línea … no sé si este se
pretende ningún trato con el código para evitar que esto ocurre.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.4 Revisar



Aquí hay un breve resumen de los asuntos cubierto en
este capítulo.





 or


Evalúa cada argumento en secuencia, y devuelve el valor del primer
argumento que no es nil, si ninguno devuelve un valor que no es
nil, devuelve nil. En breve, devuelve el primer valor de
verdad de los argumento; devuelve un valor cierto si un or
cualquier de los otros son verdad.





 and


Evalúa cada argumento en secuencia, y si cualquiera es nil,
devuelve nil; si ninguno es nil, devuelve el valor del
último argumento. En breve, devuelve un valor cierto solo si todos
los argumentos cierto; devuelve un valor cierto si un and cada
uno de los otros son ciertos.





 &optional


Una palabra clave usaba para indicar que un argumento a una
definición de función es opcional; esto significa que la función
puede ser evaluado sin el argumento, si se desea.





 prefix-numeric-value


Convierte el `argumento prefijo plano' producido por
(interactive "P") a un valor numérico.





 forward-line


Mueve el punto hacia delante al principio de la siguiente
línea, o si el argumento es más de uno, hacia delante
varias líneas. Si eso no se puede mover tan lejos
hacia delante como se puede, forward-line va hacia delante tan
lejos como se puede y entonces devuelve un contaje del número de
líneas adicionales que no pudo moverse.





 erase-buffer


Borra todos los contenidos del búffer actual.





 bufferp


Devuelve t si su argumento es un búffer; de otro modo
devuelve nil.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




5.5 Ejercicio de Argumento opcional



Escribe una función interactiva con un argumento opcional que
chequee si su argumento, un número, es mayor o igual, o al menos,
menos que el valor de fill-column, y lo escribe, en un
mensaje. Sin embargo, si no se pasa un argumento a la función, usa
56 como un valor por defecto.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




6. Extendiendo y Encogiendo






Encoger es una funcionalidad de Emacs que hace posible para ti
focalizar en una parte específica de un búffer, y
funcionar sin cambiar accidentalmente otras partes. Encoger es
normalmente deshabilitado desde que eso puede confundir a novatos.





Las Ventajas de Encoger       Las ventajas de la extender



6.1 La Forma Especial save-restriction           La forma especial save-restriction.



6.2 what-line                  El número de la línea que 
                               apunta está activa.



6.3 Ejercicio Encogiendo           











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Las Ventajas de Encoger



Con encoger, el resto del búffer se hace invisible, como si no
estuviera. Esto es una ventaja si, por ejemplo, se quiere reemplazar
una palabra en una parte del búffer pero no otro: se encoge la parte
que se quiere y el reemplazo se trae solo en esta sección, no en
el resto del búffer. Las búsquedas solo funcionarán con una
región encogida, no fuera de una, así si tu estás
arreglando una parte de un documento, se puede guardar en
sí desde encontrar partes accidentalmente que no
necesitas arreglar encongiendo solo la región que quieres. (La tecla
asociada a narrow-to-region es C-x n n.)



Sin embargo, encoger hace que el resto del búffer sea invisible,
esto puede asustar a gente quien inadvertidamente invoca a encoger y
pensar que se ha borrado una parte de su fichero. Más allá, el
comando undo (que es normalmente emparejado a C-x u) no
se deja encoger, así las personas pueden llegar a estar
bastante desesperadas si no conocen que ellas pueden volver al resto
de un búffer para visibilizarlo con el comando widen. (El
emparejamiento de la tecla para widen es C-x n w.)



Encoger es solo tan útil al intérprete Lisp como para un
humano. Con frecuencia, una función Emacs Lisp está diseñada
para trabajar en solo parte de un búffer; o de manera conversa, una
función Emacs Lisp necesita trabajar en todo un búffer que ha sido
encogido. La función what-line, por ejemplo, borra el
encogimiento desde un búffer, si eso tiene cualquier encogimiento y
cuando eso ha finalizado su trabajo, restaura el encogimiento para el
que fuera. Por otro lado, la función count-lines, que es
llamada por what-line, usa el encogimiento para restringirse a
sí misma solo a la porción del búffer en el que
está interesada y entonces restaura la situación previa.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




6.1 La Forma Especial save-restriction




En Emacs Lisp, se puede usar la forma especial save-restriction
para guardar la traza de siempre que el encogimiento esté en
efecto. Cuando el intérprete Lisp se encuentra con
save-restriction, eso ejecuta el código en el cuerpo de la
expresión save-restriction, y entonces deshace cualquier
cambio para encoger lo que el código causó. Si, por ejemplo, el
búffer está encogido y el código que sigue al comando
save-restriction devuelve el búffer para su región
encogida. En el comando what-line, cualquier encogimiento del
búffer que se puede tener se deshace por el comando widen que
inmediatamente sigue el comando save-restriction. Cualquier
encogimiento original es restaurado solo antes de la compleción de
la función.



La plantilla para una expresión save-restriction es simple:



 
(save-restriction
  body… )




El cuerpo del save-restriction es una o más expresiones que
serán evaluadas en secuencia por el intérprete Lisp.



Finalmente, un punto a anotar: cuando se usa tanto
save-excursion y save-restriction, uno correcto
después del otro, deberías usar save-excursion
fuera. Si se escribe en el orden inverso, se podría
fallar para grabar el encogimiento en el búffer para el que Emacs
cambia después de llamar a save-excursion. De este modo, cuando
se escribe junto a save-excursion y save-restriction
sería escrito así:



 
(save-excursion
  (save-restriction
    body…))




En otras circunstancias, cuando no se escribe junto, las formas
especiales save-excursion y save-restriction deben ser
escritas en el orden apropiado para la función.



Por ejemplo,



 
  (save-restriction
    (widen)
    (save-excursion
    body…))










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




6.2 what-line





El comando what-line cuenta el número de la
línea en la que el cursor se ha localizado. La
función ilustra el uso de los comandos save-restriction y
save-excursion. Aquí está el texto original de
la función:



 
(defun what-line ()
  "Imprime el número de línea actual (en el búffer)
  del punto."
  (interactive)
  (save-restriction
    (widen)
    (save-excursion
      (beginning-of-line)
      (message "Línea %d"
               (1+ (count-lines 1 (point)))))))




(En versiones recientes de GNU Emacs, la función what-line se
ha expandido para contarte el número de líneas en un
búffer encogido tan bien como tu número de línea en
un búffer ampliado. La versión reciente es más compleja que la
versión que se muestra. Si se siente venturoso, podría
querer mirarla después de figurarse como esta versión
funciona. Probablemente se necesitará usar C-h f
(describe-function). La versión nueva usa un condicional para
determinar si el búffer se ha encogido.



(También, eso usa line-number-at-pos, que otras expresiones
simples, tales como (goto-char (point-min)), mueve el punto al
principio de la línea actual con (forward-line 0)
en vez de beginning-of-line.)



La función what-line como se muestra aquí tiene
una línea de documentación y es interactiva, como se
esperaría. Las dos líneas siguientes usan
las funciones save-restriction y widen.



La forma especial save-restriction nota que encogiendo es en
efecto, si cualquiera, en el buffer actual y restaura que encogiendo
después del código en el cuerpo del save-restriction ha
sido evaluada.



La forma especial save-restriction es seguida por
widen. Esta función deshace cualquier distancia del actual
buffer que puede haber tenido cuando what-line se llame. (La
distancia que había es la distancia que
save-restriction recuerda.) Esta ampliación se hace posible
para la línea contando comandos a contar desde el
principio del búffer. De otro modo, habría sido
limitado para contar con la región accesible. Cualquier distancia
original es restaurada solo antes de la compleción de la función
por la forma especial save-restriction.



La llamada a widen es seguida por save-excursion, que
guarda la posición del cursor (por ej., el punto) y de la marca, y
la restaura después el código en el cuerpo del
save-excursion usa la función beginning-of-line para
mover el punto.



(Nótese que la expresión (widen) viene entre las formas
especiales save-restriction y save-excursion. Cuando se
escribe las dos expresiones save- … en secuencia, escribe
save-excursion finalmente.)



Las últimas dos líneas de la función
what-line son funciones para contar el número de
líneas en el búffer y entonces imprimir el número en
el área echo.



 
(message "Line %d"
         (1+ (count-lines 1 (point)))))))




La función message imprime un mensaje de una
línea abajo de la pantalla Emacs. El primer argumento
está dentro de marcas de cita y está impreso como una cadena de
caracteres. Sin embargo, se puede contener una expresión ‘%d’
para imprimir un argumento siguiente. ‘%d’ imprime el argumento
como un decimal, así el mensaje dirá alguna cosa tal
como ‘Línea 243’.



El número que está impreso en lugar de ‘%d’ está computada
por la última línea de la función:



 
(1+ (count-lines 1 (point)))





Lo que esto hace es contar las líneas desde la primera
posición del búffer indicada por el 1, subir al
(point), y entonces añadir uno a este número. (La función
1+ añade uno a su argumento.) Nosotros aãndir a eso porque
la línea 2 tiene solo una línea antes, y
count-lines cuenta solo las líneas antes
de la línea actual.



Después de que count-lines ha hecho su trabajo, y el mensaje
ha sido impreso en el área echo, la función save-excursion
restaura punto y marca a sus posiciones originales; y
save-restriction restaura la contracción original, si la hay.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




6.3 Ejercicio Encogiendo



Escribe una función que mostrará los primeros 60 caracteres del
buffer actual, incluso si se ha encogido el buffer a su mitad
así que la primera línea es
inaccesible. Restaura punto, marca y encogimiento. Para este
ejercicio, se necesita usa un popurri entero de funciones, incluyendo
save-restriction, widen, goto-char,
point-min, message, y buffer-substring.




(buffer-substring es una función previamente no mencionada
que tendrás que investigar por tí mismo; o quizás
tendrás que usar buffer-substring-no-properties o
filter-buffer-substring …, todavía otras
funciones. Las propiedades de texto son una funcionalidad que de otro
modo no serían discutidas
aquí. Véase (elisp)Propiedades de Texto sección `Propiedades de Texto' en El Manual de Referencia de Emacs Lisp.)



Además, ¿realmente se necesita goto-char o
point-min?
¿O se puede escribir la función sin ellos?








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7. car, cdr, cons: Funciones Fundamentales





En Lisp, car, cdr, y cons son funciones
fundamentales. La función cons es usada para construir
listas, y las funciones car y cdr son usadas tomarlas aparte.



En el paseo a través de la función copy-region-as-kill, se
verá cons tan bien como dos variantes de cdr, llamadas
setcdr y nthcdr. (Véase la sección  copy-region-as-kill.)





Nombres Extraños         Un lado histórico: ¿por qué 
                               los nombres extraños?



7.1 car y cdr                  Funciones para extraer parte de una lista.



7.2 cons                       Construyendo una lista.



7.3 nthcdr                     Llamando cdr repetidamente.



7.4 nth  



7.5 setcar                     Cambiando el primer elemento de una lista.



7.6 setcdr                     Cambiando el resto de una lista.



7.7 Ejercicio             











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Nombres Extraños



El nombre de la función cons es razonable: es una
abreviación de la palabra `constructo'. Los orígenes
de los nombres car y cdr, por otro lado, son
esotéricos: car es un acrónimo desde la frase `Contenidos
de la parte de la Dirección del Registro'; y cdr (pronunciado
`could-er') es un acrónimo desde la frase `Contenidos del Decremento
del Registro'. Estas frases se refieren a piezas
específicas de hardware en el ordenador en el que el
Lisp original fué desarrollado. El resto de frases han sido
completamente irrelevantes por más de 25 años a cualquiera
pensando acerca de Lisp. Ninguno, excepto unos pocos académicos
valientes han empezado a usar nombres más razonables para estas
funciones, los viejos términos están todavía en
uso. En particular, los términos usados en el código fuente Emacs
Lisp, que usaremos en esta introducción.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.1 car y cdr



El CAR de una lista es, bastatante simple, el primer
ítem en la lista. De este modo, el CAR de la lista
(rosa violeta margarita mantequilla) es rosa.



Si estás leyendo en Info y en GNU Emacs, se puede ver esto evaluando
lo siguiente:



 
(car '(rose violet daisy buttercup))




Después de evaluar la expresión, rose aparecerá en el
área echo.



Claramente, un nombre más razonable para la función car
sería first y esto es con frecuencia lo que se
sugiere.



car no elimina el primer ítem desde la lista; eso
solo informa que eso es. Después car ha sido aplicado a una
lista, la lista es todavía la misma que era. En la
jerga, car es `no-destructiva'. Esta funcionalidad deja de ser
importante.



El CDR de una lista es el resto de la lista, que es, la función
cdr que devuelve la parte de la lista que sigue el primer
ítem. De este modo, mientra el CAR de la lista
'(rosa violeta margarita mantequilla) es rosa, el resto
de la lista, el valor devuelto por la función cdr, es
(violeta margarita mantequilla).



Se puede ver esto evaluando lo siguiente del modo usual:



 
(cdr '(rosa violeta margarita mantequilla))




Cuando se evalúa esto, (violeta margarita mantequilla)
aparecerá en el área echo.



Al igual que car, cdr no elimina los elementos desde la
lista --- solo devuelve un informe de lo que el segundo y subsiguientes
elementos son.



En el ejemplo, la lista de flores se cita. Si no, el intérprete Lisp
intentaría evaluar la lista llamando a rosa como
una función. En este ejemplo, no queremos hacer esto.



Claramente, un nombre más razonable para cdr
sería rest.



(Hay una lección aquí: cuando se nombran nuevas
funciones, considere muy cuidadosamente lo que se está haciendo, ya
que puede estar pegadas con los nombres largos que se esperan. La
razón es que este doucumento perpetúa estos nombres que el
código fuente de Emacs Lisp usa, y si no los usaba, se
estaría un duro rato leyendo el código; pero, por
favor, intente evitar usar estos términos por sí
mismo. Las personas quienes vienen después se lo agradecerán.



Cuando car y cdr se aplica a una lista hecha de
símbolos, tal como la lista (pino abeto roble arce),
el elemento de la lista devuelta por la función car es el
símbolo pine sin cualquier paréntesis
alrededor. pino es el primer elemento en la lista. Sin embargo,
el CDR de la lista es una lista por sí misma,
(abeto roble arce), como se puede ver evaluando las siguientes
expresiones en el modo usual:



 
(car '(pino abeto roble arce))

(cdr '(pine fir oak maple))




Por otro lado, en una lista de listas, el primer elemento es en
sí mismo una lista. char devuelve este primer
elemento como una lista. Por ejemplo, la siguiente lista contiene tres
sublistas, una lista de carnívoros, una lista de
herbívoros y una lista de mamíferos:



 
(car '((leon tigre leopardo)
       (gacela antilope cebra)
       (ballena delfin foca)))




En este ejemplo, el primer elemento de CAR de la lista es la
lista de carnívoros, (leon tigre leopardo), y el
resto de la lista es ((gazela antílope cebra)
(delfin tiburon ballena)).



 
(cdr '((leon tigre leopardo)
       (gacela antilope cebra)
       (ballena delfin)))




Es un valor decir de nuevo que car y cdr son no
destructivos --- esto es, no se modifican o cambian listas para las
que ser aplicados. Esto es muy importante para ser usados.



También, en el primer capítulo, en la discusión
acerca de átomos, yo dije que en Lisp, ``ciertos tipos de átomos,
tales como un array, pueden separarse en partes; pero el mecanismo de
hacer esto es diferente del mecanismo de separar una lista. Desde
que Lisp se conoce, los átomos de una lista son indivisibles.''
(Véase la sección  Átomos Lisp.) El car y el cdr son funciones que
son usadas para dividir listas y son consideradas fundamentales para
Lisp. Puesto que no pueden dividir o ganar acceso a las partes de un array,
un array es considerado un átomo. De otro modo, la otra
función fundamental, cons, se puede poner cerca o construir
una lista, pero no un array. (Los arrays son manejados por funciones de
array específicas. Véase (elisp)Arrays sección `Arrays' en El Manual de Referencia de GNU Emacs Lisp.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.2 cons




La función cons construye listas; eso es lo inverso de
car y cdr. Por ejemplo, cons puede usarse para
crear una lista de cuatro elementos desde los tres elementos de la
lista, (abeto roble arce):



 
(cons 'pino '(abeto roble arce))




Después de evaluar esto, se verá lo siguiente:



 
(pino abeto roble arce)




aparece en el área echo. cons causa la creación de una
nueva lista en el que el elemento es seguido por los elementos de la
lista original.



Con frecuencia decimos que `cons pone un nuevo elemento al
principio de una lista; adjunta o empuja el elemento dentro de la lista',
pero esta frase puede ser incorrecta, puesto que cons no cambia
a una lista existente, pero crea una nueva.



Como car y cdr, cons es no destructivo.





Construir una lista  



7.2.1 Encuentra el tamaño de una Lista: length                     Cómo encontrar el tamaño de una lista.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Construir una lista



cons debe tener una lista para adjuntar a(9) No se puede
empezar desde absolutamente nada. Si se está construyendo una lista,
se necesita proveer al menos una lista vacía al
principio. Aquí hay una serie de expresiones cons
que construyen una lista de flores. Si estás leyendo esto en Info en
GNU Emacs, se puede evaluar cada una de las expresiones en el camino
usual; el valor es impreso en este texto después de ‘⇒’,
que puede leer como `evaluas para'.



 
(cons 'mantequilla ())
     ⇒ (mantequilla)



(cons 'margarita '(mantequilla))
     ⇒ (margarita mantequilla)



(cons 'violeta '(margarita mantequilla))
     ⇒ (violeta margarita mantequilla)



(cons 'rosa '(violeta margarita mantequilla))
     ⇒ (rosa violeta margarita mantequilla)




En el primer ejemplo, la lista vacía se muestra como
() y después se construye una lista de mantequilla
seguida por la lista vacía. Como se puede ver, la lista
vacía no se muestra en la lista que fué
construida. Todo lo que se ve es (mantequilla). La lista
vacía no cuenta como un elemento de una lista porque
no hay nada en una lista vacía. Generalmente hablando,
una lista vacía es invisible.



El segundo ejemplo, (cons 'margarita '(mantequilla)) construye
una nueva lista de dos elemento poniendo margarita en frente de
mantequilla; y el tercer ejemplo construye una lista de tres
elementos poniendo violeta en frente de margarita y
mantequilla.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.2.1 Encuentra el tamaño de una Lista: length




Se pueden encontrar cuantos elementos hay en una lista usando la
función Lisp length, como en los siguientes ejemplos:



 
(length '(mantequilla))
     ⇒ 1



(length '(margarita mantequilla))
     ⇒ 2



(length (cons 'violeta '(margarita mantequilla)))
     ⇒ 3




En el tercer ejemplo, la función cons es usada para construir
una lista de tres elementos que entonces se pasa a la función
length como su argumento.



Se puede también usar length para contar el número de
elementos en una lista vacía:



 
(length ())
     ⇒ 0




Como se esperaría, el número de elementos en una lista
vacía es cero.



Un experimento interesante es encontrar qué ocurre si se intenta
encontrar el tamaño de una no lista en todo; que es, si se intenta
llamar a length sin darle un argumento, incluso una lista no
vacía:



 
(length )




Lo que se ve, si se evalúa esto, es el mensaje de error



 
Lisp error: (wrong-number-of-arguments length 0)




Esto significa que la función recibe el número incorrecto de
argumentos, cero, cuando se espera algún otro número de
argumentos. En este caso, se espera un argumento, el argumento de una
lista cuyo tamaño de la función se está midiendo. (Nótese que
una lista es un argumento, incluso si la lista tiene
muchos elementos dentro.)



La parte del mensaje de error que dice @sapm{length} es el nombre de la
función.









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.3 nthcdr




La función nthcdr está asociada con la función
cdr. Que lo que hace es tomar la CDR de una lista repetidamente.



Si se toma el CDR de la lista (pine fir oak maple),
será devuelta la lista (fir oak maple). Si se repite esto en
lo que se devolvió, se devolverá lista lista (oak
maple). (De acuerdo, se repite CDR en la lista original solo se
dará CDR desde la función que no cambia la lista. Se necesita
evaluar el CDR del CDR y así.) Si se contiúa
esto, finalmente será devuelta una lista vacía, que en
este caso, en vez de ser mostrada como () es mostrado como
nil.



Para revisar, aquí hay una serie de CDRs repetidos,
el siguiente ‘⇒’ muestra que se devuelve.



 
(cdr '(pine fir oak maple))
     ⇒(fir oak maple)



(cdr '(fir oak maple))
     ⇒ (oak maple)



(cdr '(oak maple))
     ⇒(maple)



(cdr '(maple))
     ⇒ nil



(cdr 'nil)
     ⇒ nil



(cdr ())
     ⇒ nil




Tambiés se pueden hacer varios CDRs sin imprimir los valores
así:



 
(cdr (cdr '(pino abeto roble sauce)))
     ⇒ (roble sauce)




En este ejemplo, el intérprete Lisp evalúa la lista propia
dentro. La lista de dentro está entre comillas, así solo
pasa la lista del cdr más interno. Este cdr
pasa una lista hecho del segundo y subsiguientes elementos de la lista
al {cdr más externo, que produce una lista compuesta del tercer y
subsiguientes elementos de la lista original. En este ejemplo, la
función cdr se repite y devuelve una lista que consiste de
la lista original sin sus primeros dos elementos.



La función nthcdr hace lo mismo que repitiendo la llamada a
cdr. En el siguiente ejemplo, el segundo argumento se pasa a la
función nthcdr, a través con la lista, y el valor devuelto
es la lista sin sus primeros dos ítems, que son
exactamente los mismos dos cdr en la lista:



 
(nthcdr 2 '(pino abeto sauce roble))
     ⇒ (sauce roble)




Usando la lista original de cuatro elementos, se puede ver qué
ocurre cuando varios argumentos numéricos son pasados a nthcdr,
incluyendo 0, 1, y 5:



 
;; Deja la lista como estaba.
(nthcdr 0 '(pino abeto sauce roble))
     ⇒ (pino abeto sauce roble)

;; Devuelve una copia sin el primer elemento.
(nthcdr 1 '(pino abeto roble sauce))
     ⇒ (pino roble sauce)

;; Devuelve una copia de la lista sin tres elementos.
(nthcdr 3 '(pino abeto sauce roble))
     ⇒ (roble)

;; Devuelve la lista faltando los cuatro elementos.
(nthcdr 4 '(pino abeto sauce roble))
     ⇒ nil

;; Devuelve una copia sin los elementos.
(nthcdr 5 '(pino abeto sauce roble))
     ⇒ nil









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.4 nth




La función nthcdr toma el CDR de una lista
repetidamente. La función nth toma el CAR del resultado
devuelto por nthcdr. Devuelve el elemento Nth de la lista.



De este modo, si no fuera definido en C para velocidad, la
definición de nth sería:



 
(defun nth (n list)
  "Devuelve el elemento Nth de Lista.
N cuenta desde cero. Si Lista no es larga, nil es devuelto".
  (car (nthcdr n list)))




(Originalmente, nth fué definido en Emacs Lisp en
‘subr.el’, pero su definición fué rehecha en C en los 1980s.)



La función nth devuelve un elemento simple de una lista. Esto
puede ser conveniente.



Nótese que los elementos son numerados desde cero, no desde uno. Es
decir, el primer elemento de una lista, su CAR es el elemento
cero. Esto se llama contar en `base cero' y con frecuencia las
personas tienes la costumbre del que el primer elemento en una lista
sea el número uno, eso es `basado en uno'.



Por ejemplo:



 
(nth 0 '("uno" "dos" "tres"))
    ⇒ "uno"

(nth 1 '("uno" "dos" "tres"))
    ⇒ "dos"




Es valorable mencionar que nth, como nthcdr y
cdr, no cambia la lista original --- la función no es
destructiva. En contraste con las funciones setcar y
setcdr.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.5 setcar




Como se podría adivinar desde sus nombres, las funciones
setcar y setcdr asignan el CAR o la CDR de una
lista a un nuevo valor. Ellos actualmente cambia la lista original, no
como car y cdr que deja la lista original como
estaba. Un camino para encontrar como esto funciona es
experimentar. Se comenzará con la función setcar.



Primero, podemos crear una lista y entonces asignar el valor de una
variable a la lista usando la función
setq. Aquí hay una lista de animales:



 
(setq animales '(antilope jirafa leon tigre))




Si estás leyendo esto en Info dentro de GNU Emacs, se puede evaluar
esta expresión del modo usual, posicionando el cursor después de
la expresión y escribiendo @kdb{C-x C-e}. (Esto haciendo esto tan bien
aquí como yo escribo esto. Esto es una de las ventajas
de tener el intérprete construido dentro del entorno de
computación. Incidentalmente, cuando no hay nada en la
línea después del paréntesis final, tal como un
comentario, el punto puede estar en la siguiente
línea. De este modo, si tu cursor está en la primera
columna de la siguiente línea, no necesitas moverlo. En
realidad, Emacs permite cualquier cantidad de espacio en blanco
después del paréntesis final.)



Cuando se evalúa la variable animal, vemos que está
asociada a la lista (antelope giraffer lion tiger):



 
animales
     ⇒ (antilope jirafa leon tigre)




Pon otro camino, la variable animales apunta a la lista
(antilope jirafa leon tigre).



Lo siguiente, es evaluar la función setcar mientras le pasa
dos argumentos, la variable animales y el símbolo
citado hipopotamo; este es hecho escribiendo la lista de tres
elementos (setcar animales 'hipopotamo) y entonces evaluando
en el modo usual:



 
(setcar animales 'hipopotamo)




Después de evaluar esta expresión, evalúa la variable
animales de nuevo. Tu verás que la lista de animales ha cambiado:



 
animales
     ⇒ (hipopótamo jirafa leon tigre)




El primer elemento en la lista, antilope se reemplaza por
hipopotamo.



Así se puede ver que setcar no añadió un
nuevo elemento a la lista como cons tendría; eso
reemplazó antílope con hipopótamo; eso
cambió la lista.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.6 setcdr




La función setcdr es similar a la función setcar,
excepto que la función reemplaza el segundo y subsiguientes
elementos de una lista en vez del primer elemento.



(Para ver cómo se cambia el último elemento de una lista, mira hacia
delante a la función @ref{kill-new, , La funci@'on @code{kill-new}},
que usa las funciones nthcdr y setcdr.)



Para ver cómo esto funciona, asigna el valor de la variable a una
lista de animales domesticados evaluando la siguiente expresión:



 
(setq domesticated-animals '(caballo vaca oveja cabra))




Si ahora se evalúa la lista, será devuelta la lista (caballo vaca
oveja cabra):



 
animales-domesticados
     ⇒ (caballo vaca oveja cabra)




Lo siguiente, evalúa setcdr con dos argumentos, el nombre de la
variable que tiene una lista como su valor, y la lista para la que el
CDR de la primera lista sea asignada;



 
(setcdr domesticated-animals '(gato perro))




Si se evalúa esta expresión, la lista (gato perro) aparecerá
en el área echo. Este es el valor devuelto por la función. El
resultado en el que estamos interesados es el ``efecto lateral'', que
se puede ver evaluando la variable domesticated-animals:



 
domesticated-animals
     ⇒ (caballo gato perro)




En realidad, la lista es cambiada desde (caballo vaca oveja cabra)
a (caballo gato perro). El CDR de la lista es cambiada desde
(vaca oveja cabra) a (gato perro).








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




7.7 Ejercicio



Construye una lista de cuatro pájaros evaluando varias expresiones
con cons. Encuentra que ocurre cuando cons una lista
dentro de sí. Reemplaza el primer elemento de la lista
de cuatro pájaros con un pez. Reemplaza el resto de esta lista con
una lista de otro pez.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8. Cortando y Almacenando Texto









Siempre y cuando se corte o pegue texto de un búffer con un comando
`kill' en GNU Emacs, se almacenará dentro de una lista que se puede
traer con un comando `yank'.



(El uso de la palabra `kill' matar, cortar en Emacs para
procesos que específicamente no destruyen los
valores de las entidades es un accidente histórico desafortunado. Una
palabra mucho más apropiada debería ser `clip'
cortar puesto que es lo que los comandos de corte hacen; ellos
cortan texto fuera de un búffer y lo ponen dentro del almacenamiento
desde el que puede traerse. Con frecuencia ha sido tentada de
reemplazar globalmente todas las ocurrencia de `kill' matar,
cortar en las fuentes de Emacs con `clip' cortar y todas las
ocurrencias de `killed' cortado, muerto con `clipped'
cortado.)





Almacenando Texto en una Lista          El texto está almacenado en una lista.



8.1 zap-to-char                Cortando texto a un carácter.



8.2 kill-region                Cortando texto de una región.



8.3 copy-region-as-kill        Una definición para copiar texto.



8.4 Disgresión dentro C      Nota menor en macros del lenguaje de 
                               programación C.



8.5 Inicializando una Variable con defvar                     Cómo dar a una variable un valor inicial.



• Revisión cons y search-fwd  



8.7 Buscando Ejercicios          











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Almacenando Texto en una Lista



Cuando el texto se corta de un búffer, es almacenado en una
lista. Piezas sucesivas de texto se almacenan en la lista
sucesivamente, así la lista podría verse
así:



 
("una pieza de texto" "pieza previa")




La función cons puede usarse para crear una nueva lista
desde una pieza de texto (un `átomo', para usar la jerga) y una
lista existente, como esta:



 
(cons "otra pieza"
      '("una pieza de texto" "pieza previa"))




Si se evalúa esta expresión, una lista de tres elementos
aparecerá en el área echo:



 
("otra pieza" "una pieza de texto" "pieza previa")




Con las funciones car y nthcdr, se puede recuperar
siempre la pieza de texto que se quiere. Por ejemplo, en el siguiente
código, nthcdr 1 … se devuelve la lista con el primer
ítem eliminado; y el car devuelve el primer
elemento de este recuerdo --- el segundo elemento de la lista
original:



 
(car (nthcdr 1 '("otra pieza"
                 "una pieza de texto"
                 "pieza previa")))
     ⇒ "una pieza de texto"




Las funciones actuales en Emacs son más complejas que esto, de
acuerdo. El código para cortar y recuperar texto tiene que ser
escrito de modo que Emacs pueda ver qué elemento en la lista se
quiere --- el primero, segundo, tercer o cualquier otro. Además,
cuando tiene el fin de la lista, Emacs daría el primer
elemento de la lista, en lugar de nada.



La lista que maneja las piezas de texto se llama kill ring
(anillo de la muerte). Este capítulo lidera una
descripción del anillo de la muerte y como eso es usado por la
primera traza de como la función zap-to-char funciona. Este
función usa (o `llama') una función que invoca otra función que
manipula el anillo de la muerte. De este modo, antes de lograr las
montañas, se escalan las colinas.



Un capítulo subsiguiente describe como el texto que se
corta desde el búffer se recupera. Véase la sección  Cortando y Almacenando Texto.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.1 zap-to-char




La función zap-to-char cambió poco entre GNU Emacs
versión 19 y GNU Emacs versión 22. Sin embargo, zap-to-char
llama a otra función, kill-region, que se reescribió más.



La función kill-region en Emacs 19 es compleja, pero no usa
código que es importante en este momento. Se escapará.



La función kill-region en Emacs 22 es más de fácil leer
que la misma función en Emacs 19 e introduce un concepto muy
importante, que el error maneja. Nosotros pasearemos a través de la
función.



Pero primero, déjanos ver en la función interactive zap-to-char.





La Implementación Completa zap-to-char      La implementación completa.



8.1.1 La Expresión interactive    Una expresión interactiva de tres partes.



8.1.2 El Cuerpo de zap-to-char         Un resumen corto



8.1.3 La Función search-forward             Cómo buscar una cadena.



8.1.4 La Forma Especial progn                      La forma especial progn.



8.1.5 Resumiendo zap-to-char     Usando point y search-forward.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La Implementación Completa zap-to-char



La función zap-to-char elimina el texto en la región entre
la localización del curso (por ej. punto) para incluir la siguiente
ocurrencia de un caracter específico. El texto que
zap-to-char borra es puesto en el kill ring anillo de la
muerte; y puede ser recuperado desde el kill ring anillo de la
muerte escribiendo C-y (yank). Si el comando dado es un
argumento, eso borra texto a través de este número de
ocurrencias. De este modo, si el cursor estuviera al principio de esta
frase y el carácter fuera ‘s’, ‘De este modo’
sería borrado. Si el argumento fueran dos, ‘De este
modo, si el cursor’ se borrase, y incluiría la ‘s’
en el ‘cursor’.



Si el carácter específico no encuentra zap-to-char
dirá ``Búsqueda fallida'', eso cuenta el carácter que se
escribió, y no eliminó cualquier texto.



En orden para determinar cuanto texto eliminar zap-to-char usa
una función de búsqueda. Las búsquedas son usadas extensivamente
en el código que manipula texto, y focalizará la atención en
ellos tan bien como el comando de borrado.




Aquí está el texto completo de la versión 22 de la
función:



 
(defun zap-to-char (arg char)
  "Corta e incluye ARG'th ocurrencia de CHAR
En caso de ser ignorada si `case-fold-search' es no nulo en el
  búffer actual.
Para ir atrás si ARG es negativo; error si CHAR no se encuentra."
  (interactive "p\ncZap to char: ")
  (if (char-table-p translation-table-for-input)
      (setq char (or (aref translation-table-for-input char) char)))
  (kill-region (point) (progn
                         (search-forward (char-to-string char)
                                         nil nil arg)
                         (point))))




La documentación es en línea. Se necesita conocer el
significado de la jerga de la palabra `kill'.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.1.1 La Expresión interactive



La expresión interactiva en el comando zap-to-char se ve
así:



 
(interactive "p\ncZap to char: ")




La parte con comillas, "p\ncZap to char: " Cortar a
caracter, especifica dos cosas diferentes. Primero, y más simple es
el ‘p’. Este parte se separa desde la siguiente parte por una
nueva línea, ‘\n’. El ‘p’ significa que la
parte del primero argumento a la función será pasando el valor de
un `prefijo procesado'. El argumento prefijo es pasado escribiendo
C-u y un número, o M- y un número. Si la función es
llamada interactivamente sin un prefijo, el número que se pasa es 1.



La segunda parte de "p\ncZap a caracter: " es ‘cZap to
carácter:’. En esta parte, la tecla baja ‘c’ indica que
interactive espera una consola que el argumento será un
caracter. La consola sigue el ‘c’ y es la cadena ‘Zap to
caracter: ’ (con un espacio después del punto y coma para hacerlo bien).



Tod lo que hace es preparar los argumentos para zap-to-char
así ellos están en el tipo correcto, y dan al usuario
un prompt.



En un búffer de solo lectura, la función zap-to-char copia
el texto al anillo de la muerte, no se elimina. El área echo muestra
un mensaje diciendo que el búffer es de solo lectura. También, la
terminal avisa con un pitido.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.1.2 El Cuerpo de zap-to-char



El cuerpo de la función zap-to-char contiene el código que
mata (que se borra/corta) el texto en la región desde la posición
actual del cursor e incluyendo el carácter especificado.



La primera parte del código se ve como:



 
(if (char-table-p translation-table-for-input)
    (setq char (or (aref translation-table-for-input char) char)))
(kill-region (point) (progn
                       (search-forward (char-to-string char) nil nil arg)
                       (point)))




char-table-p es una función prescrita no vista. Eso determina
si sus argumentos son una tabla de caracteres. Así, se
asigna el carácter pasado a zap-to-char a uno de ellos, si
este carácter existe, o al carácter en sí. (Esto
llega a ser importante para ciertos caracteres en lenguajes no
Europeos. La función aref extrae un elemento desde un
array. Eso es una función específica de array que no
está descrita en este documento. Véase (elisp)Array sección `Arrays' en El Manual de Referencia de GNU Emacs Lisp.)



(point) es la posición actual del cursor.



La siguiente parte del código es una expresión usando
progn. El cuerpo del progn se basa en llamadas a
search-forward y point.



Es fácil comprender como progn funciona después de aprender
acerca de search-forward, así se verá en
search-forward y entonces en progn.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.1.3 La Función search-forward




La función search-forward es usada para localizar el
zapped-for-character en zap-to-char. Si la búsqueda es
exitosa, search-forward deja el punto inmediatamente después
del último carácter en la cadena objetivo. (En zap-to-char,
la cadena objetivo es solo un carácter largo. zap-to-char usa
la función char-to-string para asegurar que el ordenador
trata este carácter como una cadena.) Si la búsqueda es hacia
atrás, search-forward deja el punto solo antes del primer
carácter en el objetivo. También, search-forward devuelve
t para verdad. (Moviendo el punto allí es un
`efecto lateral'.)



En zap-to-char, la función search-forward se ve
así:



 
(search-forward (char-to-string char) nil nil arg)




La función search-forward toma cuatro argumentos:



    

  1. 
El primer argumento es el objetivo, para el que es buscado. Esto debe
ser una cadena, tal como ‘"z"’.


    Cuando eso ocurre, el argumento pasado a zap-to-char es un
caracter simple. Debido a la forma en la que los ordenadores son
construidos, el intérprete Lisp puede tratar un caracter simple
siendo diferente desde una cadena de caracteres. Dentro del ordenador,
un caracter simple tiene un formato electrónico en vez de una cadena
de un caracter. (Un caracter simple puede con frecuencia ser grabado
en el ordenador usando exactamente un byte; pero una cadena puede ser
larga, y el ordenador necesita estar listo para esto.) Desde que la
función search-forward busca una cadena, el caracter que la
función zap-to-char recibe como argumento debe ser
convertida dentro del ordenador de un formato a otro; de otro modo,
la función search-forward fallará. La función
char-to-string es usada para hacer esta conversión.

    

  2. 
El segundo argumento asocia la búsqueda; eso se especifica como
una posición en el búffer. En este caso, la búsqueda puede ir al
fin del búffer, así no se asigna y el segundo
argumento es nil.


  3. 
El tercer argumento cuenta la función que haría si la
búsqueda cae --- eso puede señalar un error (e imprimir un
mensaje) o puede devolver nil. Un nil como tercer
argumento hace que la función señale un error cuando la búsqueda
falla.


  4. 
El cuarto argumento search-forward es el contaje repetido ---
cuantas ocurrencias de la cadena para buscar. Este argumento es
opcional y si la función es llamada sin un contaje repetido, este
argumento pasa el valor 1. Si este argumento es negativo, la
búsqueda va hacia atrás.




En la forma de plantilla, una expresión search-forward se ve
así:



 
(search-forward "target-string"
                limit-of-search
                what-to-do-if-search-fails
                repeat-count)




Lo siguiente es echar un vistazo a progn.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.1.4 La Forma Especial progn




progn es una forma especial que causa que cada uno de sus
argumentos puedan ser evaluados en secuencia y entonces devuelve el valor
del último. Las expresiones precedentes son evaluadas solo por los
efectos laterales que ellos desarrollan. Los valores producidos por
ellos son descartados.



La plantilla para una expresión progn es muy simple:



 
(progn
  body…)




En zap-to-char, la expresión progn tiene que hacer dos
cosas: poner el punto en la posición exacta; y devolver la
posición del punto de modo que kill-region conoce como de
lejos se copia.



El primer argumento de progn es search-forward. Cuando
search-forward encuentra la cadena, la función deja el punto
inmediatamente después del último caracter en la cadena
objetivo. (En este caso la cadena objetivo es solo un caracter de
largo.) Si la búsqueda es hacia atrás, search-forward deja
el punto justo antes del primer carácter en el objetivo. El
movimiento del punto es un efecto lateral.



El segundo y último argumento de progn es la expresión
(point). Esta expresión devuelve el valor del punto, que en
este caso será la localización para la que se ha movido por
search-forward. (En la fuente, una línea que
cuenta la función para ir al carácter previo, si se está yendo
hacia delante, se comentó en 1999; yo no recuerdo si esta
funcionalidad o no funcionalidad era siempre parte de las fuentes
distribuidas.) El valor de point se devuelve por la expresión
progn y se pasa a kill-region como el segundo argumento
de kill-region .








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.1.5 Resumiendo zap-to-char



Ahora que se ha visto como search-forward y progn
trabajan, se puede ver cómo la función zap-to-char
funciona como un todo.



El primer argumento de kill-region es la posición del cursor
cuando el comando zap-to-char da --- el valor del punto en este
momento. Con el progn, la búsqueda de la función mueve el
punto a solo después del zapped-to-character y point devuelve
el valor de localización. La función kill-region pone junto
a estos dos valores de punto, el primero como el principio de la
región y el segundo como el fin de la región, y borra la
región.



La forma especial progn se necesita porque el comando
kill-region toma dos argumentos; y fallaría si
search-forward y expresiones point fueran escritas en
secuencia como dos argumentos adicionales. La expresión progn
es un argumento simple para kill-region y devuelve un valor
para que kill-region se necesite por su segundo argumento.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.2 kill-region




La función zap-to-char usa la función
kill-region. Esta función corta texto desde una región y
copia este texto al kill ring anillo de la muerte, desde el que
puede ser recuperado.




Tanto la versión de Emacs 22 de esta función usa
condition-case y copy-region-as-kill, ambas se
explicarán. condition-case es una forma especial importante.



En esencia, la función kill-region llama a
condition-case, que toma tres argumentos. En esta función, el
primer argumento no hace nada. El segundo argumento contiene el
código que hace el trabajo cuando todo va bien. El tercer argumento
contiene el código que se llama en el evento de un error.





La Definición Completa kill-region       La definición de función.



8.2.1 condition-case             Tratando con un problema.



8.2.2 Macro Lisp                 











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La Definición Completa kill-region



Ahora se puede volver a través del código condition-case en
un momento. Primero, se echa un vistazo a la definición de
kill-region, con comentarios añadidos:



 
(defun kill-region (beg end)
  "Kill (\"corta\") texto entre punto y marca.
Esto borra el texto desde el búffer y lo guarda en anillo de la
  muerte kill ring.
El comando \\[yank] puede recuperarse desde allí. …
 "

  ;; • Desde materias de orden, pasa el punto primero.
  (interactive (list (point) (mark)))
  ;; • Y cuéntanos si no podemos cortar el texto.
  ;; `a menos que' sea un `if' sin una then-part.
  (unless (and beg end)
    (error "La marca no está asignada ahora, así que
  no hay región"))

  ;; • `condition-case' toma tres argumentos
  ;;    Si el primer argumento es nulo, como aquí
  ;;    la información acerca del error no está
  ;;    almacenada para ser usada por otra función
  (condition-case nil

      ;; • El segundo argumento a `condition-case' cuenta lo que el
      ;;    intérprete que hace cuando todo va bien.

      ;;    Empieza con una función `let' que extrae la cadena
      ;;    y chequea si existe. Si es así (esto es lo
      ;;    que `when' chequea), eso llama a una función `if' que
      ;;    determina si el comando previo que era otra llamada para
      ;;    si el comando previo fué otra llamada a `kill-region';
      ;;    si lo era, entonces el siguiente texto se añade
      ;;    cuando se chequea), eso llama a una función `if' que
      ;;    determina si el comando previo era otra llamada a
      ;;    `kill-region'; si era eso, entonces el nuevo texto es
      ;;    añadido al texto previo; si no, entonces una función 
      ;;    diferente, `kill-new' se llama.
      ;;    La función `kill-append' concatena la nueva cadena y
      ;;    la vieja.  La función `kill-new' inserta texto dentro de
      ;;    ítem en el kill ring anillo de la muerte.

      ;;    `when' es un `if' sin una parte else.  El segundo `when'
      ;;    de nuevo chequea si la cadena actual existe; 
      ;;    por añadidura, eso chequea si el comando previo fuese
      ;;    otra llamada a `kill-region'. Si una u otra condición
      ;;    es verdadero, entoncese eso configura el actual comando a 
      ;;    ser `kill-region'.

      (let ((string (filter-buffer-substring beg end t)))
        (when string                    ;STRING is nil if BEG = END
          ;; Add that string to the kill ring, one way or another.
          (if (eq last-command 'kill-region)

              ;;    - `yank-handler' es un argumento opcional para
              ;;    `kill-region' que cuenta el `kill-append' y funciones
              ;;    `kill-new' como tratan con propiedades añadidas
              ;;    al texto, tal como `negrilla' o `itálica'
              (kill-append string (< end beg) yank-handler)
            (kill-new string nil yank-handler)))
        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        nil)

    ;;  • El tercer argumento a `condition-case' cuenta el intérprete
    ;;  qué hacer con un error.

    ;;    El tercer argumento tiene una parte de condiciones y una
    ;;    parte del cuerpo.
    ;;    Si las condiciones se encuentra (en este caso,
    ;;             si el texto o búffer son de solo lectura)
    ;;    entonces el cuerpo es ejecutado.

    ;;    La primera parte del tercer es el siguiente:
    ((buffer-read-only text-read-only) ;; parte if
     ;; …  parte then-part
     (copy-region-as-kill beg end)

     ;;    Lo siguiente, también como parte de la then-part, asigna this-command, así
     ;;    será asignado en un error
     (setq this-command 'kill-region)
     ;;    Finalmente, en la then-part, envía un mensaje
     ;;    si tu puedes copiar el texto al anillo de la muerte
     ;;    kill ring sin señalar un error, pero no si tu no puedes


     (if kill-read-only-ok
         (progn (message "Lee solo texto copiado para el kill ring") nil)
       (barf-if-buffer-read-only)
       ;; If the buffer isn't read-only, the text is.
       (signal 'text-read-only (list (current-buffer)))))










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.2.1 condition-case




Como se ha visto antes (véase la sección Genera un Mensaje de Error), cuando el intérprete Emacs Lisp tiene problemas evaluando
una expresión, se provee de una ayuda; en jerga, se dice ``signaling an
error'' señalando un error. Normalmente, el ordenador para el
programa y te muestra un mensaje.



Sin embargo, algunos programas garantizan acciones complicadas. Eso no
pararía en un error. En la función kill-region,
la mayoría parece un error que intentará cortar texto
que es de solo lectura y no puede ser eliminado. Así la
función kill-region contiene código para manejar esta
circunstancia. Este código, hace que el cuerpo de la función
kill-region, esté dentro de una forma especial
condition-case.



La plantilla para condition-case se parece a esto:



 
(condition-case
  var
  bodyform
  error-handler…)




El segundo argumento, bodyform es sencillo. La forma especial
condition-case causa que el intérprete Lisp evalúe el
código en bodyform. Si ningún error ocurre, la forma
especial devuelve el valor del código y produce efectos laterales,
si hay.



En resumen, la parte bodyform de una expresión
condition-case determina qué ocurre cuando cualquier cosa
funciona correctamente.



Sin embargo, si un error ocurre, entre sus otras acciones, la
función genera la señal de error que definirá uno o más
errores de nombres de condición.



Un manejador de errores es el tercer argumento para
condition-case. Un manejador de errores tiene dos partes, un
condition-name y un body. Si la parte condition-name
de un manejador de errores encuentra un nombre de condición generado
por un error, entonces la parte del body del manejador de errores
se ejecuta.



Como se esperaría, la parte condition-name de un
manejador de errores puede ser así, un nombre de
condición simple o una lista de nombres de condición.



También, una expresión completa condition-case puede
contener más de un manejador de errores. Cuando un error ocurre, el
primer manejador aplicable se ejecuta.



Finalmente, el primer argumento a la expresión
condition-case, es el argumento var, que es algunas veces
asignado a una variable que contiene información acerca del
error. Sin embargo, si este argumento es nulo, como es el caso en
kill-region, esta información se descarta.



En breve, en la función kill-region, el código
condition-case funciona así:



 
Si no hay errores, ejecuta solo este código
    pero, si hay errores, ejecuta este otro código.










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.2.2 Macro Lisp





La parte de la expresión condition-case que se evalúa en la
expectativa de que todo va bien si tiene un when. El código usa
when para determinar si la variable string (cadena)
apunta al texto que existe.



Una expresión when es simplemente una conveniencia de
programadores. Eso es un if sin la posibilidad de una
cláusula else. En tu mente, se puede reemplazar when con
if y comprender de que va. Esto es lo que el intérprete Lisp hace.



Técnicamente hablando, when es una macro Lisp. Una
macro Lisp permite definir una nueva construcción de control y
otras funcionalidades del lenguaje. Eso cuenta al intérprete como
computar otra expresión Lisp que dejará de computar el valor. En
este caso, la `otra expresión' es una expresión if.



La definición de función también tiene una macro unless;
que acompaña a when. La macro unless es un
if sin una cláusula then.



Para más acerca de macros Lisp, ver (elisp)Macros sección `Macros' en El Manual de Referencia de Emacs Lisp. El lenguaje de programación C
también provee macros. Estos son diferentes, pero también útiles.




Guardando la macro when, en la expresión
condition-case, cuando la cadena tiene contenido, entonces otra
expresión condicional se ejecuta. Esto es un if tanto con una
then-part y como con una else-part.



 
(if (eq last-command 'kill-region)
    (kill-append string (< end beg) yank-handler)
  (kill-new string nil yank-handler))




La parte then (then-part) se evalúa si el comando previo fué otra
llamada para kill-region; si no, se evalúa la parte else
(else-part)



yank-handler es un argumento opcional para kill-region
que cuenta que las fuciones kill-append y kill-new se
tratan con propiedades añadidas al texto, tal como `negrilla' o
`itálica'.  



last-command es una variable que viene con Emacs y que no se ha
visto antes. Normalmente, siempre y cuando una función se ejecute,
Emacs asigna el valor de last-command al comando previo. 



En este segmento de la definición, la expresión if chequea
si el comando previo era kill-region. Si era eso,



 
(kill-append string (< end beg) yank-handler)




Se concatena una copia del nuevo texto cortado al texto cortado
previamente en el kill ring anillo de la muerte.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.3 copy-region-as-kill





La función copy-region-as-kill copia una región de texto
desde un búffer y (via kill-append o kill-new) lo
guarda en el kill-ring.



Si se llama a copy-region-as-kill inmediatamente después de
un comando kill-region, Emacs inserta el texto nuevamente
copiado al texto copiado previamente. Esto significa que si se pega el
texto, se obtiene todo, tanto esto, como la operación previa. Por
otro lado, si algún otro comando precede la
copy-region-as-kill, la función copia el texto dentro de una
entrada separada el kill ring anillo de la muerte.





La definición de la función completa copy-region-as-kill.    La definición completa de función.



8.3.1 El Cuerpo de copy-region-as-kill    El cuerpo de copy-region-as-kill.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La definición de la función completa copy-region-as-kill.



Aquí está el texto completo de la versión 22
de la función copy-region-as-kill:



 
(defun copy-region-as-kill (beg end)
  "Guarda la región como si estuviera cortada, pero no la cortes.
En el modo Marca de Tránsito Transient Mark, se desactiva la
  marca.
Si `interprogram-cut-function' es no nulo, también se guarda el
  texto para una sistema de ventanas de cortar y pegar."
  (interactive "r")

  (if (eq last-command 'kill-region)
      (kill-append (filter-buffer-substring beg end) (< end beg))
    (kill-new (filter-buffer-substring beg end)))

  (if transient-mark-mode
      (setq deactivate-mark t))
  nil)




De normal, esta función puede ser dividida dentro sus componentes:



 
(defun copy-region-as-kill (argument-list)
  "documentation…"
  (interactive "r")
  body…)




Los argumentos son beg y end y la función es
interactiva con "r", así los dos argumentos deben
referir al principio y el fin de la región. Si has estado leyendo a
través de este documento desde el principio, comprediendo estas
partes de una función es casi llegando a ser rutina.



La documentación es algo confusa a menos que recuerdes que la
palabra `kill' tiene un significado diferente del usual. La `Marca
Transitoria' y interprogram-cut-function comenta explicar
cientos efectos laterales.



Después de que se ha asignado una marca, un búffer siempre
contiene una región. Si se desea se puede usar el modo Marca
Transitoria para iluminar la región temporalmente. (Nadie quiere
ilumihnar la región todo el rato, así el modo Marca
Transitoria subrraya solo en el momento apropiado. Muchas personas
desactivan el modo Marca Transitoria, así la región
nunca se ilumina.)



También, un sistema de ventanas permite copiar, cortar y pegar entre
programas diferentes. En el sistema de X windows, por ejemplo, la
función interprogram-cut-function es x-select-text,
que funciona con el sistema de ventanas equivalente del kill ring de
Emacs.



El cuerpo de la función copy-region-as-kill empieza con una
cláusula if. Lo que esta cláusula hace es distinguir entre
dos situaciones diferentes: si este comando es ejecutado o no
inmediatamente después de un comando previo kill-region. En
el primer caso, la nueva región es concatenada al texto copiado
previamente. De otro modo, eso se inserta al principio del anillo de
la muerte kill ring como una pieza separada de texto desde la
pieza previa.



Las dos líneas de la función previene la región
desde la iluminación si el modo Transient Mark Marca
Transitoria está activado.



El cuerpo de copy-region-as-kill merece discusión en detalle.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.3.1 El Cuerpo de copy-region-as-kill



La función copy-region-as-kil funciona de un modo parecido a
la función kill-region. Ambas están escritas
de un modo que dos o más textos cortados en una fila combinan
su texto en una entrada simple. Si se pega el texto desde el
anillo de la muerte kill ring, se tiene todo en una
pieza. Más allá, los cortes de textos que se cortan hacia adelante
desde la posición actual del cursor se añaden al fin del texto
copiado previamente y comanda este texto copiado vaya hacia atrás al
principio del texto copiado previamente. De este modo, las palabras en
el texto están en el orden apropiado.



Como kill-region, la función copy-region-as-kill hace
uso de la variable last-command que deja traza del comando de
Emacs previo.





last-command and this-command  



• función kill-append  



La función kill-new         











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




last-command and this-command



Normally, whenever a function is executed, Emacs sets the value of
this-command to the function being executed (which in this case would
be copy-region-as-kill).  At the same time, Emacs sets the value of
last-command to the previous value of this-command.



In the first part of the body of the copy-region-as-kill function, an
if expression determines whether the value of last-command is
kill-region.  If so, the then-part of the if expression is
evaluated; it uses the kill-append function to concatenate the text
copied at this call to the function with the text already in the first
element (the CAR) of the kill ring.  On the other hand, if the value of
last-command is not kill-region, then the
copy-region-as-kill function attaches a new element to the kill ring
using the kill-new function.



The if expression reads as follows; it uses eq:



 
  (if (eq last-command 'kill-region)
      ;; then-part
      (kill-append  (filter-buffer-substring beg end) (< end beg))
    ;; else-part
    (kill-new  (filter-buffer-substring beg end)))





(The filter-buffer-substring function returns a filtered substring of
the buffer, if any.  Optionally---the arguments are not here, so neither is
done---the function may delete the initial text or return the text without
its properties; this function is a replacement for the older
buffer-substring function, which came before text properties were
implemented.)




The eq function tests whether its first argument is the same Lisp
object as its second argument.  The eq function is similar to the
equal function in that it is used to test for equality, but differs
in that it determines whether two representations are actually the same
object inside the computer, but with different names.  equal
determines whether the structure and contents of two expressions are the
same.



If the previous command was kill-region, then the Emacs Lisp
interpreter calls the kill-append function








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




The kill-append function




The kill-append function looks like this:



 
(defun kill-append (string before-p &optional yank-handler)
  "Append STRING to the end of the latest kill in the kill ring.
If BEFORE-P is non-nil, prepend STRING to the kill.
… "
  (let* ((cur (car kill-ring)))
    (kill-new (if before-p (concat string cur) (concat cur string))
              (or (= (length cur) 0)
                  (equal yank-handler
                         (get-text-property 0 'yank-handler cur)))
              yank-handler)))





The kill-append function is fairly straightforward.  It uses the
kill-new function, which we will discuss in more detail in a moment.



(Also, the function provides an optional argument called
yank-handler; when invoked, this argument tells the function how to
deal with properties added to the text, such as `bold' or `italics'.)



It has a let* function to set the value of the first element of the
kill ring to cur.  (I do not know why the function does not use
let instead; only one value is set in the expression.  Perhaps this
is a bug that produces no problems?)



Consider the conditional that is one of the two arguments to
kill-new.  It uses concat to concatenate the new text to the
CAR of the kill ring.  Whether it prepends or appends the text depends
on the results of an if expression:



 
(if before-p                            ; if-part
    (concat string cur)                 ; then-part
  (concat cur string))                  ; else-part




If the region being killed is before the region that was killed in the last
command, then it should be prepended before the material that was saved in
the previous kill; and conversely, if the killed text follows what was just
killed, it should be appended after the previous text.  The if
expression depends on the predicate before-p to decide whether the
newly saved text should be put before or after the previously saved text.



The symbol before-p is the name of one of the arguments to
kill-append.  When the kill-append function is evaluated, it
is bound to the value returned by evaluating the actual argument.  In this
case, this is the expression (< end beg).  This expression does not
directly determine whether the killed text in this command is located before
or after the kill text of the last command; what it does is determine
whether the value of the variable end is less than the value of the
variable beg.  If it is, it means that the user is most likely
heading towards the beginning of the buffer.  Also, the result of evaluating
the predicate expression, (< end beg), will be true and the text will
be prepended before the previous text.  On the other hand, if the value of
the variable end is greater than the value of the variable
beg, the text will be appended after the previous text.



When the newly saved text will be prepended, then the string with the new
text will be concatenated before the old text:



 
(concat string cur)




But if the text will be appended, it will be concatenated after the old
text:



 
(concat cur string))




Para comprender como funciona esto, primero se necesita revisar la
función concat. La función concat enlaza junto o une
dos cadenas de texto. El resultado es una cadena. Por ejemplo:



 
(concat "abc" "def")
     ⇒ "abcdef"

(concat "new "
        (car '("first element" "second element")))
     ⇒ "new first element"

(concat (car
        '("first element" "second element")) " modified")
     ⇒ "first element modified"




Ahora puede tener sentido kill-append: eso modifica los
contenidos del anillo de la muerte kill ring. El anillo de la
muerte kill ring es una lista, en la que cada elemento es texto
guardado. La función kill-append usa la función
kill-new que usa la función setcar.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La función kill-new




La función kill-new se ve como esto:



 
(defun kill-new (string &optional replace yank-handler)
  "Crea STRING el último corte en el anillo de la muerte kill
  ring.
Asigna `kill-ring-yank-pointer' para apuntarlo.

Si `interprogram-cut-function' es no nulo, aplícalo a su
 STRING.
Segundo argumento opcional REPLACE non-significa que STRING
 reemplazará el frente del kill ring, en vez de ser aãndido a la lista.
…"

  (if (> (length string) 0)
      (if yank-handler
          (put-text-property 0 (length string)
                             'yank-handler yank-handler string))
    (if yank-handler
        (signal 'args-out-of-range
                (list string "yank-handler specified for empty string"))))

  (if (fboundp 'menu-bar-update-yank-menu)
      (menu-bar-update-yank-menu string (and replace (car kill-ring))))

  (if (and replace kill-ring)
      (setcar kill-ring string)
    (push string kill-ring)
    (if (> (length kill-ring) kill-ring-max)
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))

  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))




(Vea que la función no es interactiva.)



Normalmente, se mira a esta función en partes.



La definición de la función tiene un argumento opcional
yank-handler, que cuando se invoca cuenta la función de como
tratar con propiedades añadidas al texto, tal como `negrilla' o
`itálica'. Nosotros evitaremos esto.



La primer línea de la documentación tiene sentido:



 
Crea la CADENA la última copia en el anillo de la muerte kill ring.



Permite escapar a través del resto de la documentación por el momento.



También, permite salir de la expresión inicial if y estas
líneas de código involucrando
menu-bar-update-yank-menu. Nosotros explicaremos debajo.



Las líneas críticas son estas:



 
  (if (and replace kill-ring)
      ;; then
      (setcar kill-ring string)

    ;; else
  (push string kill-ring)

    (setq kill-ring (cons string kill-ring))
    (if (> (length kill-ring) kill-ring-max)
        ;; avoid overly long kill ring
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))

  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))




El test condicional es (and replace kill-ring). Esto será
verdad cuando dos condiciones se encuentran: el anillo de la muerte
kill ring tiene alguna cosa dentro, y la variable
replace es verdad.



Cuando la función kill-append asigna replace para ser
cierto y cuando el anillo de la muerte kill ring tiene al menos
un ítem en eso, la expresión setcar es ejecutada.



 
(setcar kill-ring string)




La función setcar actualemten cambia el primer elemento del
anillo de la muerte (kill-ring lista al valor de
string. Eso reemplaza el primer elemento.



Por otro lado, si el kill ring está vacío, o
reemplazar es falso, la else-part de la condición está ejecutado:



 
(push string kill-ring)




push pone su primer argumento dentro del segundo. Es similar al
viejo.



 
(setq kill-ring (cons string kill-ring))




o el nuevo



 
(add-to-list kill-ring string)




Cuando eso es falso, la expresión primero construye una nueva
versión del anillo de la muerte kill ring añadiendo
string al anillo de la muerte kill ring como un nuevo
elemento (que es lo que push hace). Entonces ejecuta un segundo
if cláusula. Este segundo if cláusula guarada el
anillo de la muerte kill ring desde el creciente demasiado largo.



Déjanos mirar estas dos expresiones en orden.



La línea push de la parte else asigna el nuevo
valor del kill ring anillo de la muerte a que resultados
añaden la cadena siendo cortada al viejo anillo de la muerte
kill ring



Nosotros podemos ver como esto funciona con un ejemplo.



Primero,



 
(setq example-list '("aqui una clausula" "otra clausula"))




Después de evaluar esta expresión con @kdb{C-x C-e}, se puede
evaluar example-list y mira lo que devuelve:



 
example-list
     ⇒ ("aquí hay una claúsula" "otra claúsula")




Ahora, se puede añadir un nuevo elemento en esta lista evaluando la
siguiente expresión:




 
(push "a third clause" example-list)




Cuando se evalúa example-list, se encuentra su valor es:



 
example-list
     ⇒ ("una tercera claúsula" "aquí hay una
     claúsula" "otra claúsula")




De este modo, la tercera claúsula es añadido a la lista por push.



Ahora para la segunda parte de la claúsula if. Esta
expresión deja el kill ring desde lo creciente demasiado largo. Eso
se ve de la siguiente manera:



 
(if (> (length kill-ring) kill-ring-max)
    (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))




El código chequea si el tamaño del anillo de la muerte kill
ring es más grande que el máximo tamaño permitido. Este es el
valor de kill-ring-max (que es 60, por defecto). Si el tamaño
del anillo de la muerte kill ring es demasiado largo, entonces
este código asigna el último elemento del anillo de la muerte
kill ring a nil. Eso hace esto usando dos funciones,
nthcdr y setcdr.



Nosotros vemos que setcdr temprano (véase la sección setcdr). Eso asigna el CDR de una lista, solo como
setcar asigna el CAR de una lista. En este caso, sin
embargo, setcdr no estará configurando el CDR del kill
ring completo; la función nthcdr es usada para causarlo para
asignar el CDR del siguiente al último elemento del kill ring
--- esto significa que desde el CDR del siguiente al último
elemnto del kill ring anillo de la muerte, eso asignará el
último elemento del kill ring anillo de la muerte.




La función nthcdr funciona repetidamente tomando el CDR
de una lista --- eso toma el CDR del CDR del CDR
…. Eso hace esto N veces y devuelve los
resultados. (Véase la sección  nthcdr.)




De este modo, si teniamos una lista de cuatro elemento que era
supuestamente ser de tres elementos, se podría asignar
el CDR del siguiente al último elemento a nil, y por
esto se resume la lista. (Si se asigna el último elemento a algún
otro valro que nil, que se podría hacer, entonces
tu no habrías ordenado la lista. Véase la sección  setcdr.)



Se puede ver ordenando la evaluación de las siguientes tres
expresiones en turno. Primero asigna el valor de arboles a
(arce encina pino abedul) entonces asigna el CDR de su
segundo CDR y entonces encuentra el valor de arboles.



 
(setq trees '(arce encian pino abedul))
     ⇒ (arce encina pino abedul)

(setcdr (nthcdr 2 trees) nil)
     ⇒ nil

árboles
     ⇒ (arce encina pino)




(El valor devuelto por la expresión setcdr es nil
desde que es que el CDR es asignado.)



Para repetir, en kill-new, la función nthcdr toma el
CDR un número de veces que es uno menos que el tamaño
máximo permitido del anillo de la muerte kill ring y
setcdr asigna el CDR de este elemento (que será el resto
de los elementos en el anillo muerte) para nil. Esto previene
el anillo de la muerte kill ring desde lo que crece demasiado largo.



De la siguiente a la última expresión en la función
kill-new es



 
(setq kill-ring-yank-pointer kill-ring)




El kill-ring-yank-pointer es una variable global que es
asignado para ser el kill-ring.



Incluso aunque el kill-ring-yank-pointer es llamado un
‘puntero’, eso es una variable solo como el anillo de la muerte
kill ring. Sin embargo, el nombre que ha sido elegido para
ayudar a humanos a comprender como la variable es usada.



Ahora, para devolver a una expresión temprana en el cuerpo de la
función:



 
  (if (fboundp 'menu-bar-update-yank-menu)
       (menu-bar-update-yank-menu string (and replace (car kill-ring))))




Empieza con una expresión if



En este caso, la expresión chequea primero ve si
menu-bar-update-yank-menu existe como una función, y si
así, se llama. La función fboundp devuelve
cierto si el símbolo que se chequea tiene una
definición de función que `no es vacía'. Si el
símbolo de la definición de función fuera
vacío, recibiría un mensaje de erro, como
se hizo cuando se creó errores intencionalmente (véase la sección Genera un Mensaje de Error).



La then-part contiene una expresión cuyo primer elemento es la
función and.




La forma especial and evalúa cada uno de sus argumentos hasta
que uno de los argumento devuelva un valor de nil, en cuyo caso
la expresión and devuelve @coded{nil}; sin embargo, si
ninguno de los argumentos devuelve una valor de nil, el valor
resultante desde la evaluación el último argumento es
devuelto. (Desde que tal valor no es nil, eso es considerado
cierto en Emacs Lisp.) En otras palabras, una expresión and
devuelve un valor cierto solo si todos sus argumentos son
verdaderos. (@xref{Revisi@'on del Segundo B@'uffer Relacionado}.)



La expresión determina si el segundo argumento
menu-bar-update-yank-menu es verdader o no.



menu-bar-update-yank-menu es una de la funciones que lo hace
posible para usar el menu `Seleccionar y Pegar' en el
ítem Edit de una barra de menu; usando un ratón, se
puede mirar en varias piezas de texto que se guardado y selecciona una
pieza para pegar.



La última expresión en la función kill-new añade las
cadenas nuevamente copiada a aquella facilidad que existe copiando y
pegando entre diferentes programas ejecutando un sistema de
ventanas. En el Sistema de Ventanas de X, por ejemplo, la función
x-select-text toma la cadena y la almacena en memoria operada
por X. Se puede pegar la cadena en otro programa, tal como un Xterm.



La expresión se ve como:



 
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))




Si una interprogram-cut-fuction existe, entonces Emacs ejecuta
funcall, que en vez llama su primer argumento como una
función y pasan los argumentos que permanecen a
eso. (Incidentalmente, tan lejos como se puede ver, esta expresión
if podría ser reemplazado por una expresión
and similar a uno en la primera parte de la función.)



Estamos yendo a discutir sistemas de ventanas y otros programas más
allá pero meramente nota que este es un mecanismo que habilita GNU
Emacs a trabajar fácilmente y bien con otros programas.



Este código para emplazar texot en el anillo de la muerte kill
ring, concatenado con un elemento existente o como un nuevo elemento,
nos lidera al código para traer texto que ha sido cortado del
búffer --- los comandos de corte. Sin embargo, antes de discutir los
comandos de corte, es mejor aprender como las listas son implementadas
en un ordenador. Esto hará claro tales misterios como el uso del
término `puntero'. Pero antes de esto, desviaremos dentro de C.









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.4 Disgresión dentro C






La función copy-region-as-kill (véase la sección copy-region-as-kill) usa la función
filter-buffer-substring, que en vez de eso usa la función
delete-and-extract-region. Eso elimina los contenidos de una
región y no se puede volverlos a tener.



Al contrario que el otro código discutido aquí, la
función delete-and-extract-region no es escrita en Emacs
Lisp; eso está escrito en C y es uno de las primitivas del sistema
GNU Emacs. Desde que eso es muy simple, yo haré la disgresión
brevemente desde el Lisp y se describe aquí.




Como muchas de las otras primitivas Emacs,
delete-and-extract-region es escrito como una instancia de una
macro C, una macro siendo una plantilla para codificar. La macro
completa se parece a esto:



 
DEFUN ("buffer-substring-no-properties", Fbuffer_substring_no_properties,
       Sbuffer_substring_no_properties, 2, 2, 0,
       doc: /* Devuelve los caracteres de parte del búffer,
sin las propiedades del texto.
Los dos argumentos START y END son posiciones de caracteres;
ellos pueden estar en cualquier orden.  */)
     (start, end)
     Lisp_Object start, end;
{
  register int b, e;

  validate_region (&start, &end);
  b = XINT (start);
  e = XINT (end);

  return make_buffer_string (b, e, 0);
}




Sin ir dentro de los detalles de la macro escribiendo proceso, permite
apuntar esto macro empieza con la palabra DEFUN. La palabra
DEFUN fué eleginda desde que el código sirve el mismo
propósito como defun hace en Lisp. (La macro C DEFUN
es definida ‘emacs/src/lisp.h’.)



El palabra DEFUN está seguido por siete partes dentro de los
paréntesis:





En una macro C, los parámetros son lo siguiente, con una frase de
este tipo de objeto son, seguidos por lo que podría ser
llamado el `cuerpo' de la macro. Para delete-and-extract-region
el `cuerpo' consiste de las siguientes cuatro líneas:



 
validate_region (&start, &end);
if (XINT (start) == XINT (end))
  return build_string ("");
return del_range_1 (XINT (start), XINT (end), 1, 1);




La función validate_region chequea si los valores pasados
como el principio y fin de la región son el tipo apropiado y son del
mismo rango. Si las posiciones principio y fin son la misma, entonces
devuelve y vacía la cadena.



La función del_range_1 actualmente borra el texto. Eso es una
función compleja que no miraremos. Eso actualiza el búffer y
hace otras cosas. Sin embargo. es el valorable mirando en los dos
argumentos pasados para del_range. Estos son XINT
(start) y XINT (end).



Tan lejos como el lenguaje C es concebido, start y end
son dos enteros que marcan el principio y el fin de la región para
ser borrada(10).



En las primeras versiones de Emacs, estos dos números fueron 32 bits
de longitud, pero el código está lentamente siendo generalizado
para manejar otras longitudes. Tres de los bits disponibles son usados
para especificar el tipo de información; los bits permanecen ser
usados como `contenido'.



‘XINT’ es una macro C que extrae los números relevantes desde
la colección larga de bits; los otro tres bits son descartados.



El comando en delete-and-extract-region se parece a esto:



 
del_range_1 (XINT (start), XINT (end), 1, 1);




Esto borra la región entre la posición del principio,
start, y la posición final, end.



Desde el punto de vista de la persona que escribe Lisp, Emacs es muy
simple; pero oculta en el fondo un gran trato de complejidad para
hacer todo el trabajo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.5 Inicializando una Variable con defvar







La función copy-region-as-kill es escrita en Emacs Lisp. Dos
funciones con eso, kill-append y kill-new, copiar una
región en un buffer y guardarlo en una variable llamada el
kill-ring. Esta sección describe como la variable
kill-ring es creada e inicializada usando la forma especial
defvar.



(De nuevo se nota que el término kill-ring es un sin
nombre. El texto que es cortado fuera del búffer puede ser traido;
eso no es un corpus de anillo, pero un anillo de texto resucitable.)



En Emacs Lisp, una variable tal como kill-ring es creada y dada
por un valor inicial usando la forma especial defvar. El nombre
desde ``define variable''.



La forma especial defvar es similar a setq en este se
configura el valor de una variable. Eso no es setq en dos
modos; primero solo configura el valor de la variable si la variable
no tiene ya un valor. Si la variable ya tiene un valor, defvar
no sobreescribe el valor existente. Segundo, defvar tiene una
cadena de documentación.



(Otra forma especial, defcustom, está diseñado para
variables que la gente personaliza. Eso tiene más funcionalidades
que defvar. (Véase la sección  Configurando Variables con defcustom.)





• Ver el valor de la variable actual  



8.5.1 defvar y un asterisco          











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Mirando el Actual Valor de una Variable



Se puede ver el actual valor de una variable, cualquier variable,
usando la función describe-variable, que es normalmente
invocado escribiendo C-h v. Si se escribe @kdb{C-h v} y
kill-ring (seguido por <RET>), se verá que hay en tu
anillo de la muerte actual kill ring al ser pulsado --- ¡esto
puede ser bastante tranquilo! A la inversa, si no has estado haciendo
nada esta sesión en Emacs, excepto leer este documento, se puede no
tener nada dentro. También, se verá la documentación para
kill-ring:



 
Documentación: 
Lista de secuencias de texto muerto (guardado).
Desde que el (kill ring) se supone que interactua bien con
cut-and-paste facilita ofrecer por sistemas de ventanas,
debería usar esta variable
interactúa bin con `interprogram-cut-function' y
`interprogram-paste-function'. Las funciones `kill-new',
`kill-append', y `current-kill' se suponen para implementar esta
interacción; se puede querer usarlo en vez de manipular en anillo de
la muerte kill ring directamente.



El kill ring anillo de la muerte está definido por un
defvar del siguiente modo:



 
(defvar kill-ring nil
  "Lista de secuencia de textos cortados.
…")




En esta definición de variable, la variable es dada un valor inicial
de nil, que tiene sentido, desde que si no se ha guardado nada,
no se quiere nada si se da un comando yank. La cadena de
documentación es escrito solo como la cadena de documentación de
un defun. Como con la cadena de documentación
sería una frase completa, desde que algunos comandos,
como apropos, imprime solo la primera línea de
documentación. Las líneas de exito no
serían indentadas; de otro modo se mira cuando se usa
C-h v (describe-variable).








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.5.1 defvar y un asterisco





En el pasado, Emacs usaba la forma especial defvar tanto para
variables interna que no esperaría que un usuario cambie
y para variables que espera un usuario cambie. Aunque se puede
todavía usar defvar para variables
personalizadas, por favor, usa defcustom en vez, desde que la
forma especial provee una ruta dentro de los comando de
Personalización. (Véase la sección  Especificando Variables usando defcustom.)  



Cuando tu especificaste una variable usando la forma especial
defvar, tu podrías distinguir una variable que un
usuario podría querer cambiar desde otros escribiendo,
‘*’, en la primera columna de su cadena de documentación. Por
ejemplo:



 
(defvar shell-command-default-error-buffer nil
  "*Nombre de buffer para `shell-command' … salir del error.
… ")





Tu podrías (y todavía puedes) usar el
comando set-variable para cambiar el valor de
shell-command-default-error-buffer temporalmente. Sin embargo,
las opciones configuradas usando set-variable no están
asignadas solo por la duración de tu sesión de edición. Los
nuevos valores no están guardados entre sesiones. Cada vez que Emacs
empieza, lee el valor original, a menos que tu cambia el valor con tu
fichero ‘.emacs’, si configurándolo manualmente o usando
customize. @xref{Inicializaci@'on de Emacs, , Tu Fichero
@file{.emacs}}.



Para mí, el mayor uso del comando set-variable es
sugerir variable que podría querer asignar en mi fichero
‘.emacs’. Ahora hay más de 700 variables --- tan lejos muchos
para recordar legiblemente. Afortunadamente, se puede presionar
<TAB> después llamando el comando M-x set-variable para
ver la lista de variables. (Véase (emacs)Examinando sección `Examinando y Configurando Variables' en El Manual de GNU Emacs.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.6 Revisar



Aquí hay un breve resumen de algunas funciones
introducidas recientemente.





 car


 cdr


car devuelve el primer elemento de una lista; cdr
devuelve el segundo y subsiguientes elementos de una lista.



Por ejemplo:



 
(car '(1 2 3 4 5 6 7))
     ⇒ 1
(cdr '(1 2 3 4 5 6 7))
     ⇒ (2 3 4 5 6 7)






 cons


cons construye una lista enlazando su primer argumento a su
segundo argumento.



Por ejemplo:



 
(cons 1 '(2 3 4))
     ⇒ (1 2 3 4)






 funcall


funcall evalúa su primero argumento como una función. Pasa
sus argumentos permaneciendo a su primer argumento.





 nthcdr


Devuelve el resultado de tomar CDR `n' veces en una lista.
El `resto del resto', como estaba



Por ejemplo:



 
(nthcdr 3 '(1 2 3 4 5 6 7))
     ⇒ (4 5 6 7)






 setcar


 setcdr


setcar cambia el primer elemento de una lista; setcdr
cambia el segundo y subsiguiente elementos de una lista.



Por ejemplo:



 
(setq triple '(1 2 3))

(setcar triple '37)

triple
     ⇒ (37 2 3)

(setcdr triple '("foo" "bar"))

triple
     ⇒ (37 "foo" "bar")






 progn


Evalúa cada argumento en secuencia y entonces devuelve el valor del
último.



Por ejemplo:



 
(progn 1 2 3 4)
     ⇒ 4






 save-restriction


Graba siempre que encoger esté en efecto en el búffer, si
cualquiera, restaura este encogimiento después de evaluar los argumentos.





 search-forward


Buscar una cadena, y si la cadena es encontrada, mueve el punto. Con
una expresión regular, usa algo similar a
re-search-forward. (@xref{B@'usqueda Regexp, B@'usquedas de
Expresiones Regulares}, para una explicación de expresiones
regulares patrones y búsquedas.)



search-forward y re-search-forward toma cuatro argumentos:



    

  1. 
La cadena o la expresión regular para buscar.


  2. 
Opcionalmente, el límite de la búsqueda.


  3. 
Opcionalmente, que haces si la búsqueda falla, devuelve nil o
un mensaje de error.


  4. 
Opcionalmente, cuantas veces repetir la búsqueda; si negativa, la
búsqueda va hacia atrás.






 kill-region


 delete-and-extract-region


 copy-region-as-kill




kill-region corta el texto entre punto y marca desde el
búffer y almacena que texto está en el anillo de la muerte
kill ring, así puedes obtenerlo cortándolo.



copy-region-as-kill copia es texto entre punto y marca dentro
del anillo de la muerte kill ring, desde que se puede obtener
cortando. La función no corta o borra el texto desde el búffer.






delete-and-extract-region elimina el texto en el punto y marca
desde el búffer y a través. No se puede volver. Esto no es un
comando interactivo.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




8.7 Buscando Ejercicios










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




9. Cómo las Listas se Implementan




En Lisp, los átomos es grabada en un modo sencillo, si la
implementación no es sencilla en la práctica, eso es, nada
sencillo en teoría. El átomo ‘rosa’, por ejemplo,
se graba como las cuatro letras contiguas ‘r’, ‘o’,
‘s’, ‘e’. Una lista, por otro lado, se guarda de manera
diferente. El mecanismo es igualmente simple, pero toma un momento
para tener usada la idea. Una lista se guarda usando una serie de
pares de punteros. En las series, el primer puntero en cada par de
punto al siguiente par, o al símbolo nil, que
marca el fin de la lista.



Un puntero por sí mismo es poco simple la dirección
electrónica de la que está apuntada. Aquí, una lista
es guardada como una serie de direcciones electrónicas.





• Listas diagramadas  



9.1 Símbolos como una Caja con Cajones    Explorando una metáfora poderosa.



9.2 Ejercicio            











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Listas diagramadas.



Por ejemplo, la lista (rosa violeta mantequilla) tiene tres
elementos, ‘rosa’, ‘violeta’, y ‘mantequilla’. En el
ordenador, la dirección electrónica de ‘rosa’ es grabada en un
segmento de memoria del ordenador a través de la dirección que da
la dirección electrónica de donde el átomo ‘violeta’ está
localizado; y esta dirección (uno que cuenta donde ‘violeta’
está localizado) se guarda con una dirección que cuenta donde la
dirección para el átomo ‘mantequilla’ se localiza.



Esto suena más complicado que eso y es más fácil visto en un diagrama:



 
    ___ ___      ___ ___      ___ ___
   |___|___|--> |___|___|--> |___|___|--> nil
     |            |            |
     |            |            |
     ---> rosa    ---> violeta ---> mantequilla








En el diagrama, cada caja representa una palabra de memoria del
ordenador que maneja un objeto Lisp, normalmente en la forma de una
dirección de memoria. Las cajas, por ej las direcciones, están
en pares. Cada flecha apunta a lo que la dirección es la dirección
de, si un átomo u otro par de direcciones. La primera caja es la
dirección electrónica de ‘rosa’ y los puntos de las flechas a
‘rosa’; la segunda caja es la dirección del siguiente par de
cajas, la primera parte del que es la dirección de ‘violeta’ y
la segunda parte de eso es la dirección del siguiente par. La muy
última caja apunta al símbolo nil, que marca
el fin de la lista.



Cuando una variable es configurado a una lista con una función tal
como setq, almacena la dirección de la primera caja en la
variable. De este modo, la evalúa la expresión



 
(setq bouquet '(rose violet buttercup))




crea una situación como esta:



 
ramo
     |
     |     ___ ___      ___ ___      ___ ___
      --> |___|___|--> |___|___|--> |___|___|--> nil
            |            |            |
            |            |            |
             --> rosa     --> violeta   --> mantequilla








En este ejemplo, el símbolo ramo maneja la
dirección del primer par de cajas.



Esta misma lista puede ser ilustrada en un modo diferente de
anotación de cajas como esta:



 
ramo
 |
 |    --------------       ----------------       --------------------
 |   | car   | cdr  |     | car     | cdr  |     | car         | cdr  |
  -->| rosa  |   o------->| violeta |   o------->| mantequilla |  nil |
     |       |      |     |         |      |     |             |      |
      --------------       ----------------       --------------------








(Los símbol<os de más pares de direcciones, pero la
estructura de un símbolo es hecho de direcciones. De
manera profunda, el símbolo ramo consiste de un
grupo de cajas-de-direcciones, una del que es la dirección de la
palabra impresa ‘ramo’, un segundo del que es la dirección de
una definición función adjunta al símbolo, si
cualquiera, un tercero del que es la dirección del primer para de
cajas-de-direccion para la lista (rosa violeta mantequilla), y
así. Aquí se está mostrando que la
tercera caja de dirección del símbolo apunta al primer
para de cajas-de-direccion para la lista.)



Si un símbolo es asignado al CDR de una lista, la
lista en sí no es cambiada; el símbolo
simplemente tiene una dirección abajo de la lista. (En la jerga,
CAR y CDR son `no destructivo'.) De este modo, evaluación
de la siguiente expresión



 
(setq flowers (cdr bouquet))




produce esto:





 
ramo        flores
  |              |
  |     ___ ___  |     ___ ___      ___ ___
   --> |   |   |  --> |   |   |    |   |   |
       |___|___|----> |___|___|--> |___|___|--> nil
         |              |            |
         |              |            |
          --> rosa       --> violeta  --> mantequilla










El valor de flores es (violeta mantequilla), que es
estar el símbolo flores maneja la dirección del
par address-boxes el primero que maneja la dirección de
violeta, y el segundo que maneja la dirección de
mantequilla.



Un par de cajas-de-direcciones se llama una cons cell o par
de puntos. Véase (elisp)Tipo de Célula Cons sección `la Célula Cons y los Tipos Lista' en El Manual de Referencia de Emacs Lisp, y
(elisp)Notación de Pares de Puntos sección `Notación de Pares de Puntos' en El Manual de Referencia de GNU Emacs Lisp, para más
información acerca de células cons y pares de puntos.



La función cons añade un nuevo par de direcciones al frente
de una serie de direcciones como son mostradas debajo. Por ejemplo,
evaluando la expresión



 
(setq bouquet (cons 'lily bouquet))




produce:





 
ramo                       flores
  |                             |
  |     ___ ___        ___ ___  |     ___ ___       ___ ___
   --> |   |   |      |   |   |  --> |   |   |     |   |   |
       |___|___|----> |___|___|----> |___|___|---->|___|___|--> nil
         |              |              |             |
         |              |              |             |
          --> lila      --> rosa       --> violeta    --> mantequilla










Sin embargo, esto no cambia el valor del símbolo
flowers, así puedes ver evaluando lo siguiente,



 
(eq (cdr (cdr ramo)) flores)




que devuelve t para verdad.



Hasta que se resetea, flores todavía tiene el
valor de (violeta mantequilla); que es, eso tiene la
dirección de la celula cons cuya primera dirección es
violeta. También, esto no altera cualquier célula
prexistente cons; ellas está todavía allí.



De este modo, en Lisp, tiene el CDR de una lista, se obtiene la
dirección del siguiente cons en las serie; para tener el CAR de
una lista, se obtiene la dirección del primer elemento de la lista;
para cons un nuevo elemento en una lista, se añade una nueva
célula cons al frente de la lista. ¡Esto es todo lo que hay
así! La estructura subyacente de Lisp es brillantemente
simple!



¿Y qué hace la última dirección en una serie de
células cons
se refieren? Eso es la dirección de la lista vacía, de
nil.



En resumen, cuando una variable Lisp es asignada a un valor, eso
provee con la dirección de la lista lo que la variable se refiere.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




9.1 Símbolos como una Caja con Cajones






En una sección temprana, se sugería que se
podría imaginar un símbolo siendo una caja
con cajones. La definición de función es puesto en un cajón, el
valor en otro, y así. Que es puesto en el cajón
manejando el valor puede ser cambiado sin afectar a los contenidos del
cajón manejando la definición de función, y viceversa.



Actualmente, lo que está puesto en cada cajón es la dirección
del valor o definición de función. Eso es como si se encontrara un
viejo cajón en el ático, y en uno de sus cajones se encontrara un
mapa dándote direcciones a donde está el tesoro escondido.



(Además de su nombre, la definición del símbolo, y
un valor de la variable, un símbolo tiene un `cajón'
para una lista de propiedades que puede ser usada para grabar
otra información. Las listas de propiedades no se discuten
aquí; ver (elisp)Listas de Propiedades sección `Listas de Propiedades' en El Manual de Referencia de Emacs Lisp.)



Aquí hay una representación visionaria:





 
            Caja de Cajones            Contenidos de Cajones

            __   o0O0o   __
          /                 \
         ---------------------
        |    direcciones al   |            [mapeo a]
        | nombre del simbolo  |             ramo
        |                     |
        +---------------------+
        |  direcciones a la   |
        |  definición del   |             [nunca]
        |    simbolo          |
        +---------------------+
        |    direcciones al   |            [mapeo a]
        |   valor de variable |       (rosa violeta mantequilla)
        |                     |
        +---------------------+
        |    direcciones a la |
        |lista de propiedades |             [no descrito aquí]
        |                     |
        +---------------------+
        |/                   \|















[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




9.2 Ejercicio



Asignar flores a violeta y mantequilla. Asigna
dos flores más en esta lista y asigna esta nueva lista a
more-flowers. Asigna el CAR de flores a un
pez. ¿Qué lista contiene ahora mas-flores?








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




10. Pegando Texto







Siempre y cuando se corta texto fuera de un búffer con un comando
`kill' en GNU Emacs, se puede traer con un comando `copiar'. El texto
que cortado del búffer es puesto en el anillo de la muerte y en los
comandos copiar, insertan los contenidos apropiados del kill ring
detrás de un búffer (no necesariamente el búffer original).



Un simple comando C-y (yank) inserta el primer
ítem desde el anillo de la muerte kill ring
dentro del actual búffer. Si el comando C-y es seguido
inmediatamente para M-y, el primer elemento es reemplazado por
el segundo elemento. Los sucesivos comandos M-y reemplazan el
segundo elemento con el tercer, cuarto, o quinto elemento, y
así. Cuando el último elemento en el anillo de la
muerte kill ring se logra, eso es reemplazado por el primer
elemento y el ciclo se repite. (De este modo, el kill ring se llama un
`anillo' en vez de solo una `lista'. Sin embargo, la estructura de de
datos actual que maneja el texto es una lista. @xref{Anillo de la
Muerte, , Manejando el Anillo de la Muerte @emph{Kill Ring}}, para los
detalles de como la lista es manejada como un anillo.)





• Resumen del Anillo de la Muerte  



10.2 La Variable kill-ring-yank-pointer     El anillo de la muerte es una lista.



10.3 Ejercicios con yank y nthcdr     La variable kill-ring-yank-pointer.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




10.1 Resumen del Anillo de la Muerte.




El anillo de la muerte kill ring es una lista de cadenas
textuales. Esto es lo que se ve:



 
("algun texto" "una pieza diferente pieza de texto"
"todavía más texto")




Si esto fueran los contenidos de mi anillo de la muerte kill
ring y yo presionara C-y, la cadena de caracteres dicendo
‘algún texto’ sería insertado en este búffer
donde mi cursor está localizado. 



El comando yank pegar es también usado para duplicar
texto copiándolo. El texto copiado no es cortado desde el búffer,
pero una copia de eso es puesto en el anillo de la muerte kill
ring y está insertado pegándolo.



Tres funciones son usadas para atraer texto desde el anillo de la
muerte kill ring: yank (pegar), que es
normalmente asociado a C-y; yank-pop, que es normalmente
asociado a M-y; y rotate-yank-pointer, que es usado por
las otras dos funciones.



Estas funciones se refieren al kill ring anillo de la muerte a
través de una variable llamada el kill-ring-yank-pointer. En
vez, la inserción del código para ambos las funciones yank y
yank-pop son:



 
(insert (car kill-ring-yank-pointer))




(Bien, no más. En GNU Emacs 22, la función ha sido reemplazada por
insert-for-yank que llama a insert-for-yank-1
repetitivamente para cada segmento yank-handler. En vez de eso,
insert-for-yank-1 destituye las propiedades de texto desde el
texto insertado de acuerdo a yank-excluded-properties. De otro
modo, eso es como insert. Nosotros pegamos con un insert
plano desde que eso es fácil de comprender.)



Para empezar a comprende como yank y yank-pop funcionan,
eso primero es necesario mirar en la variable
kill-ring-yank-pointer.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




10.2 La Variable kill-ring-yank-pointer



kill-ring-yank-pointer es una variable, solo como
kill-ring es una variable. Eso apunta a alguna cosa siendo
asignada al valor de lo que apunta, como cualquier otra variable Lisp.



De este modo, si el valor del kill ring es:



 
("algun texto" "una pieza diferente pieza de texto"
"todavía más texto")




y el kill-ring-yank-pointer apunta a la segunda cláusula, el
valor de kill-ring-yank-pointer es:



 
("una pieza diferente de texto" "todavía más texto")




Como se explica en el capítulo previo
(@pxref{Implementaci@'on de Lista}), el ordendor no guarda dos copias
diferentes del texto siendo apuntado por ambos el kill-ring
anillo de la muerte y el kill-ring-yank-pointer. Las
palabras ``una pieza diferente de texto'' y ``todavía
más texto'' no están duplicados. En vez de eso, las dos variables
Lisp apuntan a las mismas piezas de texto. Aquí hay un
diagrama:



 
kill-ring     kill-ring-yank-pointer
    |               |
    |      ___ ___  |     ___ ___      ___ ___
     ---> |   |   |  --> |   |   |    |   |   |
          |___|___|----> |___|___|--> |___|___|--> nil
            |              |            |
            |              |            |
            |              |             --> "todavía más texto"
            |              |
            |               --> "una pieza diferente de texto"
            |
             --> "algo de texto"










Ambos la variable kill-ring y la variable
kill-ring-yank-pointer son punteros. Pero el kill ring
anillo de la muerte en sí es normalmente descrito
como si fuera actualmente de lo que está compuesto. El
kill-ring es hablado de lo que fuera la lista en vez de lo que
apunta a la lista. Conversando, el kill-ring-yank-pointer es
habldo de como se apunta a una lista.



Estas dos maneras hablar acerca de la misma cosa suena confuso al
principio pero tiene sentido reflexión. El kill ring anillo de
la muerte es generalmente pensado como la estructura completa de
datos que manejan la información de lo que tiene ha sido cortado
reciéntemente de los buffers de Emacs. El
kill-ring-yank-pointer en la otra mano, sirve para indicar ---
que es, para `apuntar a' --- esta parte del anillo de la muerte del
que el primer elemento (el CAR) será insertado.









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




10.3 Ejercicios con yank y nthcdr










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11. Bucles y Recursión






Emacs List tiene dos caminos primarios para causar una expresión, o
una serie de expresiones, para ser evaluado repetidamente: uno usa un
bucle while, y el otro usa recursion.



Repetición puede ser valorable. Por ejemplo, para mover hacia
delante cuantro frases, tu solo necesitas escribir un programa que
moverá hacia delante una frase y entonces repite el proceso cuatro
veces. Ya que un ordenador no está aburrido o cansado, tal acción
repetitiva no tiene los efectos de borrado por equivocación o exceso
que pueden tener los humanos.



La gente mayoritariamente escribe funciones de Emacs Lisp usando
bucles while; pero se puede usar recursión, que provee un
poderoso camino para pensar acerca y entonces para resolver
problemas(11).





11.1 mientras                   Causando una estrechez de código para repetir



11.2 Ahorra tiempo: dolist y dotimes  



11.3 Recursión                Causando que una función se llame a 
                               sí mismo.



11.4 Ejercicio de Bucles         











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.1 mientras





La forma especial while testea si el valor devuelto por evaluar
su primer argumento es verdadero o falso. Esto es similar para que el
intérprete Lisp hace con un if; que el intérprete hace lo
siguiente, sin embargo, es diferente.



En una expresión while, si el valor devuelto por evaluar el
primer argumento es falso, el intérprete Lisp escapa del resto de la
expresión (el cuerpo de la expresión) y no lo evalúa. Sin
embargo, si el valor es cierto, el intérprete Lisp evalúa el
cuerpo de la expresión y entonces de nuevo chequea si el primer
argumento para while es cierto o falso. Si el valor devuelto de
evaluar el primer argumento es cierto de nuevo, el intérprete Lisp
evalúa el cuerpo de la expresión.



La plantilla para una expresión while se ve así:



 
(while true-or-false-test
  body…)






Bucles con while               Repetir tantas veces como el test devuelva 
                               verdadero.



11.1.1 Un bucle while y una Lista           Un bucle while que usa una lista.



11.1.2 Un Ejemplo: print-elements-of-list     Usos while, car, cdr.



11.1.3 Un Bucle con un Contaje Incremental     Un bucle con un contador de incremento.



• Incrementando Detalles de Bucles  



11.1.4 Bucle con un contador Decrementando        Un bucle con un decrementando contador.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Bucles con while



Tan largo como el true-or-false-text de la expresión while
devuelve un valor cierto cuando eso es evaluado, el cuerpo es
repetidamente evaluado. Este proceso es llamado como un bucle desde
que el intérprete Lisp repite la misma cosa una y otra vez, como un
avión haciendo un bucle. Cuando el resultado de evaluar el
true-or-false-test es falso, el intérprete Lisp no evalúa el resto
de la expresión while y `existe el bucle'.



Claramente, si el valor devuelto evaluando el primer argumento para
while es siempre cierto, el cuerpo siguiendo será evaluado
una y otra vez … y … para
siempre. Recíprocamente, si el valor devuelto nunca es
cierto, las expresiones en el cuerpo nunca serán evaluadas. La
fortaleza de escribir un bucle while consiste de elegir un
mecanismo tal que el true-or-false-test devuelva cierto solo el
número de veces que quieres las subsiguientes expresiones para ser
evaluadas, y entonces tener el test devuelto falso.



El valor devuelto evaluando while es el valor del
true-or-false-test. Una consecuencia interesante de esto es que un
bucle while que evalúa sin error devolverá nil o
falso sin dignidad de si eso ha girado 1 o 100 veces o ninguna. Una
expresión while que evalúa de manera exitosa nunca devuelve
un valor cierto! Lo que esto significa es que while es siempre
evaluado por sus efectos laterales, que es decir, las consecuencias de
evaluar las expresiones con el cuerpo del bucle while. Esto
tiene sentido. Eso no es el mero acto del bucle que es deseado, pero
las consecuencias de lo que ocurre cuando las expresiones en el bucle
son repetidamente evaluadas.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.1.1 Un bucle while y una Lista



Un camino común para controlar un bucle while es chequear si
una lista tiene cualquier elemento. Si eso se hace, el bucle es
repetido; pero si no, la repetición se finaliza. Desde esto es una
técnica importante, creará un corto ejemplo para ilustrarlo.



Un camino simple para chequear si una lista tiene elementos es evaluar
la lista: si eso no tiene elementos, si es una lista
vacía y devolverá la lista vacía,
(), que es un sinónimo para nil o falso. Por otro
lado, una lista con elementos devolverá estos elementos cuando eso
es evaluado. Desde que Emacs Lisp considera como cierto cualquier
valor que no es nil, una lista que devuelve elementos
chequeará cierto en un bucle while.



Por ejemplo, se puede asignar la variable empty-list a
nil por evaluar la siguiente expresión setq:



 
(setq empty-list ())




Después de evaluar la expresión setq, se puede evaluar la
variable empty-list es el camino normal, posicionando el cursor
después del símbolo y escribiendo C-x C-e;
nil aparecerá en tu área echo:



 
empty-list




Por otro lado, si se asigna una variable para ser una lista con
elementos, la lista aparecerá cuando se evalúe la variable, como
se puede ver evaluando las siguientes dos expresiones:



 
(setq animals '(gacela jirafa leon tigre))

animales



De este modo, para un bucle while que chequea si hay cualquier
ítem en la lista animales, la primera parte del
bucle será escrito así:



 
(while animals
       …




Cuando el while chequea su primer argumento, la variable
animals es evaluada. Eso devuelve una lista. Tan largo como la
lista tiene elementos, el while considera los resultados del
test para ser verdadero; pero cuando la lista es vacía,
eso considera los resultados del test para ser falso.



Para prevenir que el bucle while se ejecute siempre, algún
mecanismo necesita ser proporcionado la lista vacía
eventualmente. Una técnica usada con frecuencia es tener una de las
subsiguientes formas en la expresión while asigna el valor de
la lista para ser el CDR de la lista. Cada vez que la función
cdr es evaluada, la lista será hecha, hasta que finalmente
solo la lista vacía será a la izquierda. En este
punto, el test del bucle while devolverá falso, y los
argumentos para el while no será evaluado largamente.



Por ejemplo, la lista de animales emparejadas a la variables
animals puede ser asignada a ser el CDR de la lista
original con la siguiente expresión:



 
(setq animals (cdr animals))




Si se han evaluado las expresiones previas y entonces evalúan esta
expresión, se verá (jirafa leon tigre) aparecerá en el
área echo. Si se evalúa la expresiń de nuevo, (leon
tigre) aparecerá en el área echo. Si se evalúa de nuevo y
todavía de nuevo, (tigre) aparecerá y entonces
la lista vacía, se mostrará por nil.



Una plantilla para un bucle while que usa la función
cdr repetidamente para causar el true-or-false-test
eventualmente para testear falso se parece a esto:



 
(while test-whether-list-is-empty
  body…
  set-list-to-cdr-of-list)




Este testea y usa cdr puede ser puesto junto en una función
que va a través de una lista e imprima cada elemento de la lista en
una línea de sí.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.1.2 Un Ejemplo: print-elements-of-list




La función print-elements-of-list ilustra un bucle
while con una lista.




La función requiere varias líneas por su salidad. Si
estás leyendo esot en una instancia reciente de GNU Emacs, se puede
evaluar la siguiente expresión dentro de Info, de normal.



Si estás usando una versión temprana de Emacs, se necesita copiar
las expresiones necesarias para tu búffer ‘*scratch*’ y
evaluarlo allí. Esto es porque el área echo
tenía solo una línea en las versiones
tempranas.



Se pueden copiar de las expresiones marcando el principio de la
región con C-<SPC> (set-mark-command), moviendo el
cursor al fin de la región y entonces copiando la región usando
@kdb{M-w} (kill-ring-save, que llama a
copy-region-as-kill y entonces provee realimentación
visual). En el búffer ‘*scratch*’, se puede copia las
expresiones atrás escribiendo @kdb{C-y} (yank).



Después de haber copiado las expresiones al búffer
‘*scratch*’, evalúa cada expresión por turnos. Asegúrese
evaluar la última expresión, (print-elements-of-list
animals), escribiendo C-u C-x C-e, que es, dando un argumento
para eval-last-sexp. Esto causará el resultado de la
evaluación para ser impreso en el búffer ‘*scratch*’ en vez
de siendo impreso en el área echo. (De otro modo se verá alguna
cosa como esto en tu  área echo:
^Jgacela^J^Jjirafa^J^Jleon^J^Jtigre^Jnulo, en cada ‘^J’ se
estructura una `nueva línea'.)



En una instancia de GNU Emacs reciente, se puede evaluar estas
expresiones directamente en el buffer Info, y el área echo crecerá
para mostrar los resultados.



 
(setq animals '(gacela jirafa leon tigre))

(defun print-elements-of-list (list)
  "Print each element of LIST on a line of its own."
  (while list
    (print (car list))
    (setq list (cdr list))))

(print-elements-of-list animals)




Cuando se evalúan las tres expresiones en secuencia, se verá esto:



 
gacela

jirafa

leon

tigre
nil




Cada elemento de la lista es impreso en una línea de
sí (que es lo que la función print hace) y
entonces el valor devuelto por la función es impresa. Desde que la
última expresión en la función es el bucle while, y
desde que el bucle while siempre devuelve nil, un
nil es impreso después el último elemento de la lista.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.1.3 Un Bucle con un Contaje Incremental



Un bucle no es útil a menos que pare cuando
podría. Bajo el control de un bucle con una lista, un
camino común de parar un bucle es escribir el primer argumento como
un test que devuelve falso cuando el número correcto de repeticiones
es completo. Esto significa que el bucle debe tener un contados ---
una expresión que cuenta cuantas veces el bucle se repite a
sí mismo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Detalles de un Bucle de Incremento



El test para un bucle con un contador de incremento puede ser una
expresión tal como (< count desired-numberj) que devuelve
t para verdad si el valor de count es menor que el
desired-number de repeticiones y nil para falso si el
valor de count es igual a o es mayor que el
desired-number. La expresión que incrementa el contador puede
ser un simple setq tal como (setq count (1+ count)),
donde 1+ es una función construida en Emacs Lisp que añade
1 a su argumento. (La expresión (1+ count) tiene el mismo
resultado que (+ count 1), pero es fácil para un humano leer.)



La plantilla para un bucle while controlado por un contador
incrementando se parece a esto:



 
set-count-to-initial-value
(while (< count desired-number)         ; true-or-false-test
  body…
  (setq count (1+ count)))              ; incrementer




Note que se necesita asignar el valor inicial de count;
normalmente es asignado a 1.





Ejemplo con contador incremental      Contando esquinas en un triángulo.



Las partes de la definición de función      Las partes de la definición función.



Poniendo la definición de la función junta          Poniendo la definición de función junta.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Ejemplo con contador incremental



Supón que estás jugando la playa y decidir para crear un
triángulo de asteriscos, poniendo un asterisco en la primera fila,
dos en la segunda fila, tres en la tercera fila y así,
como esto:





 
               *
              * *
             * * *
            * * * *






(Hace 2500 años, Pitágoras y otras desarrollaron los principios de
la teoría de números considerando preguntas como esta.)



Supón que quieres saber cuantos asteriscos necesitarás crear un
triángulo con 7 filas



Claramente, lo que necesitas hacer es añadir los números de 1 a
7. Hay dos caminos para hacer esto; comienza los números más
pequeños, uno, y añade la lista en secuencia, 1, 2, 3, 4 y
así; o empieza con el número más largo y añade la
lista bajando: 7, 6, 5, 4 y así. Porque ambos mecanismos
ilustra caminos comunes de escribir bucle while, crearemos dos
ejemplos, uno contando hacia arriba y el otro contando hacia abajo. En
este primer ejemplo, empezaremos con 1 y añadimos 2, 3, 4 y
así.



Si estás añadiendo un resumen de lista de números, el camino
más fácil para hacer eso es añadir todos los números a la
vez. Sin embargo, si no sabes en frente cuantos números tendrá tu
lista, o si quieres estar preparado para una lista muy larga, entonces
se necesita diseñar tu adición así que hacer es
repetir un proceso simple muchas veces en vez de hacer un proceso
más complejo.



Por ejemplo, en vez de añadir todas los asteriscos todo a la vez,
que se puede hacer es añadir el número de asteriscos en la primera
fila, 1, para el número en la segunda fila, 2, y entonces añadir
el total de estas dos filas a la tercera fila, 3. Entonces se puede
añadir el número en la cuarta fila, 4, al total de las primeras
tres filas; y así.



La característica crítica del proceso es
que cada acción repetitiva es simple. En este caso, en cada paso
nosotros añadimos solo dos números, el número de asteriscos en
la fila y el total ya encontrado. Este proceso de añadir dos
números es repetido de nuevo y de nuevo hasta la última fila que
ha sido añadida al total de todas las filas precedentes. En un
bucle más complejo la acción repetitiva podría no
ser tan simple, pero será tan simple que haciendo cada cosa una vez.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Las partes de la definición de función



El análisis precedente nos da los bonos de nuestra definición de
función: primero, necesitaremos una variable que podemos llamar
total que será el número total de asteriscos. Esto será
el valor devuelto por la función.



Segundo, sabemos que la función requerirá un argumento: este
argumento será el número de filas en el triángulo. Eso puede ser
llamado number-of-rows.



Finalmente, se necesita una variable para usar como un contador. Se
podría llamar esta variable counter, pero un
nombre mejor es row-number. Esto es porque que el contador hace
en esta función es contar filas, y un programa debería
ser escrito para ser comprendido como posible.



Cuando el intérprete Lisp primero empieza evaluando las expresiones
en la función, el valor de total estaría
asignado a cero, ya que no hemos añadido cualquier cosa a
eso. Entonces la función añadiría el número de
asteriscos en la primera fila al total, y entonces añade el número
de asteriscos en la segunda al total, y entonces añade el número
de asteriscos en la tercera fila al total, y así, hasta
que no hay más filas a la izquierda para añadir.



Ambos total y row-number son usados solo dentro de la
función, así ellos pueden ser declarados como
variables locales con let y valores iniciales
dados. Claramente, el valor inicial para total sería
0. El valor inicial de row-number sería 1, desde
que se comienza con la primera fila. Esto significa que la frase
let se parece a esto:



 
  (let ((total 0)
        (row-number 1))
    body…)




Después de que las variables internas son declaradas y asignadas a
sus valores iniciales se podría empezar el bucle
while. La expresión que sirve como el test
devolvería un valor de t para la verdad tan
grande como el row-number es menor o igual al
number-of-rows. (Si la expresión chequea cierto solo tan
largo como el número de fila es menor que el número de filas en el
triángulo, la última fila nunca será añadida al total;
aquí el número de fila tiene que ser menor o igual el
número de filas.)




Lisp provee la función <= que devuelve cierto si el valor de
su primer argumento es menor o igual al valor de su segundo argumento
y falso de otro modo. Así la expresión que el
while evaluará como si su test se vería como esto:



 
(<= row-number number-of-rows)




El número de asteriscos puede ser encontrado repetidamente
añadiendo el número de asteriscos en una fila al total ya
encontrado. Dede el número de asteriscos en la fila es igual al
número de fila, el total puede ser encontrado añadiendo el
número de filas al total. (Claramente, en una situación más
compleja, el número de asteriscos en la fila podría
ser relacionada al número de la fila en un camino más complicado;
si este fuera el caso, el número de fila sería
reemplazado por la expresión apropiada.)



 
(setq total (+ total row-number))




Lo que esto hace es asignar el nuevo valor de total ser igual a
la suma de añadiendo el número de asteriscos en la fila al total previo.



Después de configura el valor de total, las condiciones
necesitan ser establecidas para la siguiente repetición del bucle,
si hay una. Esto es hecho incrementando el valor de la variable
row-number, que sirve como un contador. Después que la
variable row-number ha sido incrementada, el true-or-false-test
al principio del bucle while chequea si su valor es
todavía menor o igual al valor del number-of-rows
y si eso es, añade el nuevo valor de la variable row-number
al total de la repetición del bucle.



La función construida en Emacs Lisp 1+ añade 1 a un
número, así la variable row-number puede ser
incrementado con esta expresión:



 
(setq row-number (1+ row-number))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Poniendo la definición de la función junta



Nosotros hemos creado las partes para la definición de la función;
ahora necesitamos ponerlo junto.



Primero, los contenidos de la expresión while:



 
(while (<= row-number number-of-rows)   ; true-or-false-test
  (setq total (+ total row-number))
  (setq row-number (1+ row-number)))    ; incrementer




A lo largo de la expresión let de varlist, esta muy cerca de
completar el cuerpo de la definición de función. Sin embargo, eso
requiere un elemento final, la necesidad para la que es alguna cosa
pequeña.



El toque final es emplazar la variable total en una
línea por sí misma después de la
expresión while. De otro modo, el valor devuelto por la
función completa es el valor de la última expresión que es
evaluada en el cuerpo del let, y este es el valor devuelto por
el while que es siempre nil.



Esto puede no ser evidente a primera vista. Eso casi se ve como si la
última expresión de la función completa. Pero esta expresión
es parte del cuerpo del while; eso es el último elemento de
la lista que empieza con el símbolo while. Más
allá, el completo del bucle while es una lista con el cuerpo
del let. 



En línea (outline), la función se parece a esto:



 
(defun name-of-function (argument-list)
  "documentation…"
  (let (varlist)
    (while (true-or-false-test)
      body-of-while… )
    … ))                    ; Necesita la expresión final aquí.




El resultado de evaluar el let es que lo que está yendo para
ser devuelto el defun desde el let no está embebido
con cualquier lista que contiene, excepto para la defun como un
todo. Sin embargo, si el while es el último elemento de la
expresión let, la función siempre devolverá
nil. Esto no es lo que quiero! En vez de eso, lo que
queremos es el valor de la variable total. Esto es devuelto
simplemente emplazando el símbolo como el último
elemento de la lista empezando con let. Eso está evaluado
después de los elementos precedentes de la lista evaluada, que
significa que eso evaluó después de haber sido asignado el valor
correcto para el total.



Eso puede ser fácil de ver esto imprimiendo la lista empezando con
let todo en una línea. Este formato lo hace
evidente que las expresiones varlist y while son el
segundo el tercer elementos de la lista empezando con let, y el
total es el último elemento:



 
(let (varlist) (while (true-or-false-test) body-of-while… ) total)




Poniendo cualquier cosa junta, la definición de función
triangle se parece a esto:



 
(defun triangle (number-of-rows)    ; Versión con
                                    ;  contador de incremento.
  "Añade el número de asteriscos en un triángulo.
La primera fila tiene un asterisco, la segunda fila dos asteriscos,
la tercera fila tres asteriscos, y así.
El argumento es NUMBER-OF-ROWS."

  (let ((total 0)
        (row-number 1))
    (while (<= row-number number-of-rows)
      (setq total (+ total row-number))
      (setq row-number (1+ row-number)))
    total))




Después tu has instalado triangle por evaluar la función,
se puede probar fuera. Aquí hay dos ejemplos:



 
(triangle 4)

(triangle 7)




La suma del primer de cuatro números es 10 y la suma de los primeros
siete números es 28.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.1.4 Bucle con un contador Decrementando



Otro camino común para escribir un bucle while es para
escribir el test así que eso determina si un contador es
mayor que cero. Así tan largo es el contador mayor que
cero, el bucle es repetido. Pero cuando el contador es igual o menor
que cero, el bucle se para. Para este trabajo, el contador tiene que
empezar mayor que cero y entonces ser hecho más pequeño y
pequeño por una forma que es evaluado repetidamente.



El test será una expresión tal como (> counter 0) que
devuelve t para cierto si el valor de counter es mayor
que cero, y nil para falso si el valor de counter es
igual a o menor que cero. La expresión que hace el número menor y
menor puede ser un simple setq tal como (setq counter (1-
counter), donde 1- es una función construida en Emacs Lisp
que sustrae 1 de su argumento.



La plantilla para decrementar el bucle while se ve como esto:



 
(while (> counter 0)                    ; true-or-false-test
  body…
  (setq counter (1- counter)))          ; decrementer






Ejemplo con el contador que se decrementa    Más piedras en la playa.



Las partes de la definición de función      Las partes de la definición función.



Poniendo la definición de la función junta          Poniendo la definición de función junta.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Ejemplo con el contador que se decrementa



Para ilustrar un bucle con un contador de decremento, reescribirá la
función triangle así el contador decrementar a cero.



Esto es lo inverso de la versión temprana de la función. En este
caso, para encontrar cuantos asteriscos son necesarios para crear un
triángulo con 3 filas, añade el número de asteriscos en la
tercera fila, 3, para el número en la fila precedente, 2, y entonces
añade el total de estas dos filas a la fila que lo precede, que es 1.



Más allá, para encontrar el número de asteriscos en un
triángulo con 7 filas, añade el número de asteriscos en la fila
siete, 7, al número en la fila precedente, que es 6, y entonces
añade el total de estas dos filas a la files esta que los precede,
que es 5, y así. Como en el ejemplo previo, cada
adición solo involucra la adición de dos números, el total de
las filas ya añadió y el número de asteriscos en la fila que
está siendo añadida al total. Este proceso de añadir dos
números es repetido de nuevo y de nuevo hasta que no haya más
asteriscos que añadir.



Sabemos cuantos asteriscos empezar: el número de asteriscos en la
última fila es igual al número de filas en la última fila es
7. Más allá, sabemos cuantos asteriscos están en la fila
precedente: eso es uno menos que el número en la fila.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Las partes de la definición de función



Empezamos con tres variables: el número total de filas en el
triángulo; el número de asteriscos en una fila; y el número
total de asteriscos, que es que queremos calcular. Estas variables
puede ser nombradas number-of-rows,
number-of-pebbles-in-row, y total, respectivamente.



Ambos total y number-of-pebbles-in-row son usados solo
dentro de la función y son declaradas con let. El valor
inicial de total sería cero. Sin embargo, el
valor inicial de number-of-pebbles-in-row sería
igual al número de filas en el triángulo, desde la adición
empezará con la fila más larga.



Esto significa que el principio de la expresión let se verá
como esto:



 
(let ((total 0)
      (number-of-pebbles-in-row number-of-rows))
  body…)




El número total de asteriscos pueder ser encontrado repetidamente
añadiendo el número de asteriscos en una fila para el total ya
encontrado, que es, repetidamente evaluando la siguiente expresión:



 
(setq total (+ total number-of-pebbles-in-row))




Después el number-of-pebbles-in-row se añade al
total, el number-of-pebbles-in-row sería
decrementado por uno, desde que la siguiente vez el bucle repite, la
fila precedente será añadido al total.



El número de asteriscos en una fila precedente es uno menos que el
número de asteriscos en una fila, así la función
Emacs Lisp construida 1- puede ser usado para computar el
número de asteriscos en la fila precedente. Esto puede ser hecho con
la siguiente expresión:



 
(setq number-of-pebbles-in-row
      (1- number-of-pebbles-in-row))




Finalmente, sabemos que el bucle while pararía
creando repetidas adiciones cuando no hay asteriscos en una
fila. Así el este para el bucle while es simple:



 
(while (> number-of-pebbles-in-row 0)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Poniendo la definición de la función junta



Podemos poner estas expresiones juntas para crear una definición de
función que funcione. Sin embargo, al examinar, encontraremos que
uno de la variables locales es innecesario!



La definición de función se ve como esto:



 
;;; First subtractive version.
(defun triangle (number-of-rows)
  "Add up the number of pebbles in a triangle."
  (let ((total 0)
        (number-of-pebbles-in-row number-of-rows))
    (while (> number-of-pebbles-in-row 0)
      (setq total (+ total number-of-pebbles-in-row))
      (setq number-of-pebbles-in-row
            (1- number-of-pebbles-in-row)))
    total))




Como se dijo, esta función funciona.



Sin embargo, no se necesita number-of-pebbles-in-row.




Cuando la función triangle es evaluada, el
símbolo number-of-rows será asociado al
número, dando un valor inicial. Este número puede ser cambiado en
el cuerpo de la función si estuviera una variable local, sin miedo
que tal cambio efectuará el valor de la variable fuera de la
función. Esto es muy útil característica de Lisp;
eso significa que la variable number-of-rows puede ser usado en
cualquier lugar en la función donde number-of-pebbles-in-row
es usada.



Aquí es una segunda versión de la función escrita un
poco más limpiamente:



 
(defun triangle (number)                ; Second version.
  "Return sum of numbers 1 through NUMBER inclusive."
  (let ((total 0))
    (while (> number 0)
      (setq total (+ total number))
      (setq number (1- number)))
    total))




En breve, un bucle while apropiadamente escrito consistirá de
tres partes:



    

  1. 
Un test que devolverá falso después de que el bucle ha repetido
por sí mismo el número de veces correcto.


  2. 
Una expresión la evaluación de que devolverá el valor deseado
después siendo repetidamente evaluado.


  3. 
Una expresión para cambiar el valor pasado al true-or-false-test
así que el test devuelve falso después el bucle ha
repetido por sí mismo el número de veces correcto.









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.2 Ahorra tiempo: dolist y dotimes



Además para while, ambos dolist y dotimes
provee para bucle. Algunas veces estos son rápidos para escribir que
el equivalente bucle while. Ambos son macros
Lisp. (Véase (elisp)Macros sección `Macros' en El Manual de Referencia GNU Emacs Lisp.)



dolist funciona como un bucle while que `CDRs baja
una lista': dolist automáticamente ordena la lista cada vez
que la lista hace bucles --- toma la CDR de la lista --- y asocia
el CAR de cada versión ordenada de la lista al primero de sus
argumentos.



dotimes hace el bucle de un número específico
de veces: tu especificas el número.





La Macro dolist  



La Macro dotimes                    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La Macro dolist




Supón, por ejemplo, que quieres invertir una lista,
así que ``primero'', ``segundo'', ``tercero'' llega a
ser ``tercero'', ``segundo'', ``primero''.



En la práctica, usarías la función reverse,
como esta:



 
(setq animals '(gacela jirafa leon tigre))

(reverse animals)




Aquí es como se podría invertir la lista
usando un bucle while:



 
(setq animals '(gacela jirafa leon tigre))

(defun reverse-list-with-while (list)
  "Usando while, invierte el orden de LIST."
  (let (value)  ; make sure list starts empty
    (while list
      (setq value (cons (car list) value))
      (setq list (cdr list)))
    value))

(reverse-list-with-while animals)




Y aquí es como podría usar la macro
dolist:



 
(setq animals '(gacela jirafa leon tigre))

(defun reverse-list-with-dolist (list)
  "Usando dolist, reverse, la orden de la LISTA."
  (let (value)  ; asegura que la lista empieza vacía
    (dolist (element list value)
      (setq value (cons element value)))))

(reverse-list-with-dolist animals)




En Info, se puede localizar su cursor después de cerrar paréntesis
de cada expresión y escribir C-x C-e; en cada caso, se
vería



 
(tiger lion giraffe gazelle)




en el área echo.



Para este ejemplo, la función reverse existente es obviamente
la mejor. El bucle while es solo como nuestro primer ejemplo
(véase la sección Un Bucle while y una Lista). El
while primero chequea si la lista tiene elementos; si
así, eso construye una nueva lista añadiendo el primer
elemento de la lista a la lista existente (que en la primera
iteración del bucle es nil). Desde el segundo elemento está
asignado en frente del segundo elemento, la lista es inversa.



En la expresión usando un bucle while, la expresión
(setq list (cdr list)) ordena la lista, así
el bucle while eventualmente para. Además, se proporciona la
expresión cons con un nuevo primer elemento creando un nuevo
y corta lista en cada repetición del bucle.



La expresión dolist hace mucho lo mismo como la expresión
while, excepto que la macro dolist hace algo del trabajo
tienes que hacer cuando escribe una expresión while.



Como un bucle while, un bucle dolist. Lo que es
diferente es que automáticamente ordena la lista cada vez que se
repita --- eso `CDRs baja la lista en sí --- y eso
automáticamente asocia el CAR de cada versión ordenada de la
lista al primero de sus argumentos.



En el ejemplo, el CAR de cada versión ordenada de la lista se
refiere a usar el símbolo ‘element’, la lista en
sí se llama ‘list’, y el valor devuelto se llama
‘value’. El recuerdo de la expresión dolist es el cuerpo.



La expresión dolist asocia el CAR de cada versión
resumida de la lista al element y entonces evalúa el cuerpo
de la expresión y repite el bucle. El resultado es devuelto en
value.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La Macro dotimes




La macro dotimes es similar para dolist, excepto que el
bucle es un número específico de veces.



El primer argumento dotimes es asignado a los números 0, 1, 2
y así el cuarto cada vez alrededor del bucle, y el valor
del tercer argumento es devuelto. Se necesita proveer el valor del
segundo argumento, que es cuantas veces la macro hace el bucle.



Por ejemplo, lo siguiente asocia los números desde 0 a, pero no
incluyendo, el número 3 al primer argumento, numero, y
entonces construye una lista de los tres números. (El primer
número es 0, el segundo número es 1, y el tercer número es 2;
esto crea un total de tres números en todo, empezando con cero como
el primer número.)



 
(let (value)      ; de otro modo un valor es una variable vacía
  (dotimes (number 3 value)
    (setq value (cons number value))))

⇒ (2 1 0)




dotimes devuelve value, así el camino para
usar dotimes es para operar en alguna expresión number
número de veces y entonces devuelve el resultado, como una lista o
un átomo.



Aquí hay un ejemplo de una defun que usa
dotimes para añadier el número de asteriscos en un triángulo.



 
(defun triangle-using-dotimes (number-of-rows)
  "Usando dotimes, añade el número de asteriscos en un triángulo."
(let ((total 0))  ; de otro modo un total es una variable vacía
  (dotimes (number number-of-rows total)
    (setq total (+ total (1+ number))))))

(triangle-using-dotimes 4)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3 Recursión




Una función recursiva contiene código que cuente el intérprete
Lisp para llamar a un programa que ejecuta exactamente por
sí mismo, pero con argumentos ligeramente diferentes. El
código ejecuta exactamente el mismo porque eso tiene el mismo
nombre. Sin embargo, incluso aunque el programa tiene el mismo nombre,
eso no es la misma entidad. Eso es diferente. En la jerga, eso es una
`instancia' diferente.



Eventualmente, si el programa es escrito correctamente, los
`argumentos ligeramente diferentes' llegan a ser suficientemente
diferentes desde los primeros argumentos que la instancia final parará.





11.3.1 Construyendo Robots: Extendiendo la Metáfora        Mismo modelo, diferente número serie ...



11.3.2 Las Partes de una Definición Recursiva    Paseo hasta que tu pares ...



11.3.3 Recursión con una Lista      Usando una lista con el test si para recurso.



• Función de triángulo recursivo  



11.3.5 Ejemplo de Recursión Usando cond  



11.3.6 Patrones Recursivos        Plantillas usadas con frecuencia.



11.3.7 Recursión sin Defermentos                No almacenar trabajo ...



11.3.8 No hay solución pospuesta    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.1 Construyendo Robots: Extendiendo la Metáfora





Es algunas veces útil pensar de un programa en ejecución como un
robot que hace un trabajo. Haciendo su trabajo, una función
recursiva llama a un segundo robot para ayudarlo. El segundo robot es
idéntico al primero en cada camino, excepto que el segundo robot
ayuda al primero y ha sido pasado diferentes argumentos que el primero.



En una función recursiva, el segundo robot puede llamar a un
tercero; y el tercero puede llamar a un cuarto, y
así. Cada una de estos es una entidad diferente; pero
todos son clones.



Desde que cada robot tiene instrucciones ligeramente diferentes ---
los argumentos diferirán desde un robot al siguiente --- el último
robot conocería cuando pare.



Permite expandir en la metáfora en el que un programa de ordenador
es un robot.



Una definición de función provee impresiones para un robot. Cuando
se instala una definición de función, que es, cuando se evalúa
una forma especial defun, se instala el equipamiento para
construir robots. Eso es como si tu estuvieras en una fábrica,
configurando una línea de ensamblaje. Los robots con el
mismo nombre son construidos de acuerdo a las mismas
impresiones. Así ellos tienen, como estaban, el mismo
`número de modelo', pero un diferente `número de serie'.



Nosotros con frecuencia decimos que una función recursiva `se llama
así misma'. Esto significa que las instrucciones en una
función recursiva causa el intérprete de Lisp para ejecutar una
función diferente que tiene el mismo nombre y hace el mismo trabajo
como el primer, pero con diferentes argumentos.



Eso es importante que los argumentos difieren desde una instancia al
siguiente; de otro modo, el proceso nunca parará.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.2 Las Partes de una Definición Recursiva





Una función recursiva típicamente contiene una
expresión condicional que tiene tres partes:



    

  1. 
Un true-or-false-test que determina si la función es llamada de
nuevo, aquí llamado el do-again-test.


  2. 
El nombre de la función. Cuando este nombre es llamado, una nueva
instancia de la función --- un nuevo robot, como eso estaba --- es
creado y contado qué hacer.


  3. 
Una expresión que devuelve un valor diferente cada vez la función
es llamada, aquí llamada la
next-step-expression. Consecuentemente, el argumento (o
argumentos) pasados a la nueva instancia de la función será
diferente desde que pas' a la instancia previa. Esto causa la
expresión condicional, el do-again-test, para chequear falso
después del número correcto de repeticiones.




Las funciones recursivas pueden ser más simples que cualquier otro
tipo de funciones. De manera profunda, cuando la gente primero empieza
a usarlas, ellos con frecuencia miran así
misteriosamente tan simple como incompresible. Como montar en
bicicleta, leer una función recursiva toma una cierta forma que es
dura al principio pero entonces parece simple.



Hay varios patrones recursivos diferentes. Un patrón muy simple se
parece a:



 
(defun name-of-recursive-function (argument-list)
  "documentation…"
  (if do-again-test
    body…
    (name-of-recursive-function
         next-step-expression)))




Cada vez una función recursiva es evaluado, una nueva instancia de
eso es creada y cuenta que hacer. Los argumentos cuentan la instancia
de que hacer.



Un argumento es emparejado al valor de la next-step-expresion. Cada
instancia se ejecuta con un valor diferente de la next-step-expression.



El valor en la next-step-expression es usado en la do-again-test.



El valor devuelto por la next-step-expression es pasada a las nuevas
instancias de la función, que lo evalúa (o alguna transformación
de eso) para determinar si continuar o para. El next-step-expression
está diseñados así que el do-again-test devuelve
falso cuando la función no sería largamente repetido.



El do-again-test es algunas veces llamada la condición de
parar, desde que eso para la repeticiones cuando eso testea falso.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.3 Recursión con una Lista



El ejemplo de un bucle while que imprimió los elementos de
una lista de números puede ser escrito
recursivamente. Aquí está el código, incluyendo una
expresión para asignar el valor de la variable animales a una
lista.



Si estás usando GNU Emacs 20 o antes, este ejemplo debe ser copiado
al búffer ‘*scratch*’ y cada expresión debe ser evaluado
allí. Usa C-u C-x C-e para evaluar la expresión
(print-elements-recursively animals así que los
resultados son impresos en el búffer; de otro modo el intérprete
Lisp intentará presionar los resultados dentro de una
línea del área echo.



También, posiciona tu cursor inmediatamente después del último
paréntesis que cierra la función
print-elements-recursively, antes el comentario. De otro modo,
el intérprete Lisp intentará evaluar el comentario.



Si estás usando una versión más reciente de Emacs, se puede
evaluar esta expresión directamente en Info.




 
(setq animals '(gacela jirafa leon tigre))

(defun print-elements-recursively (list)
  "Imprime cada elemento de LISTA en una línea de
  sí.
Usa recursión."
  (when list                            ; do-again-test
        (print (car list))              ; body
        (print-elements-recursively     ; recursive call
         (cdr list))))                  ; next-step-expression

(print-elements-recursively animals)




La función print-elements-recursively primero chequea si hay
cualquier contenido en la lista; si hay eso, la función imprime el
primer elemento de la lista, el CAR de la lista. Entonces la
función `invoca en sí', pero da a sí
mismo como su argumento, no la lista completa, pero el segundo y
subsiguientes elementos de la lista, el CDR de la lista.



Pon otro camino, si la lista no está vacía, la
función invoca otra instancia de código que es similar al código
inicial, pero es un hilo diferente de ejecución, con diferentes
argumentos que la primera instancia.



Pon en todavía otro camino, si la lista no está
vacía, el primer robot ensambla un segundo robot cuenta
qué hacer; el segundo robot es un individuo diferente desde el
principio, pero es el mismo modelo.



Cuando la segunda evaluación ocurre, la expresión when es
evaluada y si es verdad, imprime el primer elemento de la lista que
recibe como su argumento (que es el segundo elemento de la lista
original). Entonces la función `llamarse a sí mismo'
con la CDR del CDR de la lista original.



Note que aunque nosotros decimos que la función `se llama a
sí misma', lo que significa es que el intérprete Lisp
ensambla e instruye una nueva instancia del programa. La nueva
instancia es un clon del primero, pero es un individuo separado.



Cada vez que la función `se invoca a sí misma', se
invoca a sí misma en una versión de la lista
original. Eso crea una nueva instancia que funciona en una lista ordenada.



Eventualmente, la función se invoca a sí misma en una
lista vacía. Eso crea una nueva instancia cuyo argumento
es nil. La expresión condicional chequea el valor de
lista. Desde el valor de lista es nil, la
expresión when chequea falso así la then-part
no está evaluada. La función como un todo entonces devuelve nil.



Cuando se evalúa la expresión (print-elements-recursively
animals) en el búffer ‘*scratch*’, se verá este resultado:



 
gacela

jirafa

leon

tigre
nil









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.4 Recursión en Lugar de un Contador




La función triangle describe en una sección previa si puede
ser escrita recursivamente. Se ve así:



 
(defun triangle-recursively (number)
  "Return the sum of the numbers 1 through NUMBER inclusive.
Uses recursion."
  (if (= number 1)                    ; do-again-test
      1                               ; then-part
    (+ number                         ; else-part
       (triangle-recursively          ; recursive call
        (1- number)))))               ; next-step-expression

(triangle-recursively 7)




Se puede instalar esta función evaluando y entonces intenta evaluar
(triangle-recursively 7). (Recuerda poner tu cursor
inmediatamente después de los últimos paréntesis de la
definición de la función, antes del comentario.) La función
evalúa a 28.



Para comprender como funciona la función, permita considerar que
ocurre en los varios casos cuando la función es pasada 1, 2, 3, o 4
como el valor de su argumento.





• Argumento de Ejemplo Recursivo de 1 o 2  



Un argumento de 3 o 4    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Un argumento de 1 o 2



Primero, veamos que ocurre si el valor del argumento es 1



La función tiene una expresión if después de la cadena de
documentación. Esto testea si el valor de number es igual a
1; si es así, Emacs evalúa la then-part de la
expresión if, que devuelve el número 1 como el valor de la
función. (Un triángulo con una fila tiene un asterisco dentro.)



Supón, sin embargo, que el valor del argumento es 2. En este caso,
Emacs evalúa la parte else de la expresión if.



La parte else consiste de una adición, la llamada recursiva para
triangle-recursively y una acción de decremento; y se ve
así:



 
(+ number (triangle-recursively (1- number)))




Cuando Emacs evalúa esta expresión, la expresión interna es
evaluada primero; entonces las otras partes en
secuencia. Aquí están los pasos en detalle:





 Paso 1   Evalúa la expresión interna.




La expresión interna es (1- number) así Emacs
decrementa el valor de number desde 2 a 1.





 Paso 2   Evalúa la función triangle-recursively.




El intérprete Lisp crea una instancia individual de
triangle-recursively. Eso no importa que esta función está
contenida con sí misma. Emacs pasa el resultado Paso 1
como el argumento usado por esta instancia de la función
triangle-recursively



En este caso, Emacs evalúa triangle-recusrively con un
argumento de 1. Esto significa que esta evaluación de
triangle-recursively devuelve 1.





 Paso 3   Evalúa el valor de number.




La variable number es el segundo elemento de la lista que
empieza con +; su valor es 2.





 Paso 4    Evalúa la expresión +.




La expresión + recibe dos argumentos, el primero desde la
evaluación de number (Paso 3) y el segundo desde la
evaluación de triangle-recursively (Paso 2).



El resultado de la adición es el suma de 2 + 1, y el número 3 es
devuelto, que es correcto. Un triángulo con dos filas tiene tres
asteriscos ahí.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Un argumento de 3 o 4



Supón que triangle-recursively es llamado con un argumento de
3.





 Paso 1   Evalúa la do-again-test.




La expresión if es evaluado primero. Esto es el test do-again
y devuelve falso, así la parte else de la expresión
if es evaluado. (Note que en este ejemplo, el do-again-test
causa la función para llamarse a sí mismo cuando eso
se chequea como falso, no cuando eso se chequea como verdadero.)





 Paso 2   Evalúa la expresión propia de la parte else.




La expresión propia de la parte es evaluada, decrementa 3 a 2. Esta
la next-step-expression.





 Paso 3   Evalúa la función triangle-recursively.




El número 2 es pasado a la función triangle-recursively.



Nosotros ya sabemos qué ocurre cuando Emacs evalúa
triangle-recursively con un argumento de 2. Después de ir a
través de la secuencia de acciones descrito temprano, eso devuelve
un valor de 3. Así que es lo que ocurrirá
aquí.





 Paso 4   Evalúa la adición.




3 será pasado como un argumento para la adición y será añadido
al número con el que la función se llamó, que es 3.






El valor devuelto por la función como un todo será 6.



Ahora que sabemos qué ocurrirá cuando triangle-recursively
es llamado con un argumento de 3, eso es evidente que ocurrirá si
eso es llamado con un argumento de 4:



En la llamada recursiva, la evaluación de



 
(triangle-recursively (1- 4))




devuelve el valor de evaluar



 
(triangle-recursively 3)




que es 6 este valor será añadido a 4 por la adición en la
tercera línea.




El valor devuelto por la función como un todo será 10.



Cada vez triangle-recursively es evaluado, eso evalúa una
versión de sí --- una instancia diferente de
sí --- con un pequeño argumento, hasta que el
argumento es suficientemente pequeño así que no se
evalúa por sí.



Note que este particular diseño para una función recursiva
requiere que las operaciones sean diferidas.



Antes (triangle-recursively 7) puede calcular su respuesta, eso
debe llamarse (triangle-recursively 6); y antes
(triangle-recursively 5); y así. Esto es decir,
el cálculo que (triangle-recursively 7) crear debe ser
diferido hasta (triangle-recursively 6) hace su cálculo; y
(triangle-recursively 5) completo; y así.



Si cada una de estas instancias de triangle-recursively son
pensados de como diferentes robots, el primer robot debe esperar por
el segundo para completar su trabajo, que debe esperar hasta los
terceros completos, y así.



Hay un camino alrededor de este tipo de espera, que discutirá en
@ref{No Defermenta, , Recursi@'on sin Defermentos.}








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.5 Ejemplo de Recursión Usando cond




La versión de triangle-recursively descrito antes es escrito
con la forma especial if. Eso puede también ser escrito
usando otra forma especial llamada cond. El nombre de la forma
especial cond es una abreviación de la palabra ‘conditional’.



Aunque la forma especial cond no es usado con frecuencia en las
fuentes de Emacs como if, eso es usado con suficiente
frecuencia para justificarse explicando.



La plantilla para una expresión cond se parece a esto:



 
(cond
 body…)




donde el body es una serie de listas.



Escrito de manera más completa, la plantilla se parece a esto:



 
(cond
 (first-true-or-false-test first-consequent)
 (second-true-or-false-test second-consequent)
 (third-true-or-false-test third-consequent)
  …)




Cuando el intérprete Lisp evalúa la expresión cond,
evalúa el primer elemento (el CAR o true-or-false-test) de la
primera expresión es una serie de expresiones con el cuerpo del
cond.



Si el true-or-false-test devuelve nil el resto de esta
expresión, el consecuente, se escapa y el true-or-false-test de la
siguiente expresión es evaluada. Cuando una expresión encuentra
cuyo true-or-false-test un valor que no es nil, el conscuente
de esta expresión es evaluada. El consecuente puede ser una o más
expresiones. Si el consecuente consiste de más de una expresión,
las expresiones son evaluadas en secuencia y el valor del último es
devuelto. Si la expresión no tiene un consecuente, el valor del
true-or-false-test es devuelto.



Si ninguno del test true-or-false-tests es cierto, la expresión
cond devuelve nil.



Escrito usando cond, la función triangle se parece a esto:



 
(defun triangle-using-cond (number)
  (cond ((<= number 0) 0)
        ((= number 1) 1)
        ((> number 1)
         (+ number (triangle-using-cond (1- number))))))




En este ejemplo, el cond devuelve 0 si el número es menor o
igual que 0, eso devuelve 1 si el número es 1 y eso evalúa
(+ number (triangle-using-cond (1- number))) si el número es
más grandes que 1.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.6 Patrones Recursivos




Aquí hay tres patrones recursivos. Cada uno involucra
una lista. Recursión no necesita para involucrar listas, Lisp está
diseñado para listas y esto provee un sentido de sus capacidades
primarias.





Patrón Recursivo: cada  



Patrón Recursivo: accumulate  



Patrón Recursivo: keep                    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Patrón Recursivo: cada





En el patrón recursivo cada, una acción es desarrollado en
cada elemento de una lista.



El patrón básico es:





Aquí está el ejemplo:



 
(defun square-each (numbers-list)
  "Square each of a NUMBERS LIST, recursively."
  (if (not numbers-list)                ; do-again-test
      nil
    (cons
     (* (car numbers-list) (car numbers-list))
     (square-each (cdr numbers-list))))) ; next-step-expression

(square-each '(1 2 3))
    ⇒ (1 4 9)




Si numbers-list está vacío, no hagas nada. Pero
si eso tiene contenido, construye una lista combinando la
raíz del primer número en la lista con el resultado de
la llamada recursiva.



(El ejemplo sigue el patrón exactamente: nil es devuelto si
la lista de números es vacía. En la práctica, tu
escribirías el condicional así trae la
acción cuando la lista de números no es vacía.)



La función print-elements-recursively (véase la sección Recursión con una Lista) es otro ejemplo de un patrón
every, excepto en este caso, en vez de traer los resultados
juntos usando cons, se imprime cada elemento de salida.



La función print-elements-recursively se parece a esto:



 
(setq animals '(gazelle giraffe lion tiger))

(defun print-elements-recursively (list)
  "Imprime cada elemento de LISTA en una línea de
  sí.
Usa recursión."
  (when list                            ; do-again-test
        (print (car list))              ; body
        (print-elements-recursively     ; recursive call
         (cdr list))))                  ; next-step-expression

(print-elements-recursively animals)




El patrón para print-elements-recursively es:









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Patrón Recursivo: accumulate





Otro patrón recursivo es llamado el patrón accumulate. En
el patrón recursivo accumulate, una acción es medida en
cada elemento de una lista y el resultado de esta acción es
acumulada con los resultados de desarrollar la acción de los otros
elementos.



Esto es mucho como `cada' patrón usando cons, excepto este
cons no está usado, pero algún otro combinador.



El patrón es:





Aquí hay un ejemplo:



 
(defun add-elements (numbers-list)
  "Añade los elementos de NUMBERS-LIST juntos."
  (if (not numbers-list)
      0
    (+ (car numbers-list) (add-elements (cdr numbers-list)))))

(add-elements '(1 2 3 4))
    ⇒ 10




@xref{Lista Ficheros, , Creando una Lista de Ficheros}, por un ejemplo
del patrón acumulativo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Patrón Recursivo: keep





Un tercer patrón es llamado el patrón keep. En el patrón
recursivo keep, cada elemento de una lista es testeado; el
elemento actúa y los resultados son guardados solo si el elemento
encuentra un criterio.



De nuevo, esto es parecido a `cada' patrón, excepto si el elemento
se escapa a menos que encuentra un criterio.



El patrón tiene tres partes:





Aquí hay un ejemplo que usa cond:



 
(defun keep-three-letter-words (word-list)
  "Guarda 3 palabras en WORD-LIST."
  (cond
   ;; Primero do-again-test: stop-condition
   ((not word-list) nil)

   ;; Segundo do-again-test: cuando actuar
   ((eq 3 (length (symbol-name (car word-list))))
    ;; combina el elemento que actúa con la llamada recursiva en la
   lista ordenada
    (cons (car word-list) (keep-three-letter-words (cdr word-list))))

   ;; Tercero do-again-test: cuando se escape el elemento;
   ;; recursivamente llama a la lista ordenada con la next-step expression
   (t (keep-three-letter-words (cdr word-list)))))

(keep-three-letter-words '(uno dos tres cuatro cinco seis))
    ⇒ (uno dos seis)




Eso va sin decir que no necesitas usar nil como el test para
cuando para; y se puede, de acuerdo, combina estos patrones.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.7 Recursión sin Defermentos





Permite considerar de nuevo que ocurre con la función
triangle-recursively. Nosotros encontraremos que los cálculos
son deferidos hasta todo puede ser hecho.



Aquí está la definición de función:



 
(defun triangle-recursively (number)
  "Devuelve la suma de los números 1 a través de NUMBER inclusive
Usa recursión."
  (if (= number 1)                    ; do-again-test
      1                               ; then-part
    (+ number                         ; else-part
       (triangle-recursively          ; recursive call
        (1- number)))))               ; next-step-expression




¿Qué ocurre cuando se llama a esta función con un
argumento de 7?



La primera instancia de la función triangle-recursively
añade el número 7 al valor devuelto por una segunda instancia de
triangle-recursively, una instancia que ha sido pasado un
argumento de 6. Esto es decir, el primer cálculo es:



 
(+ 7 (triangle-recursively 6))




La primera instancia de triangle-recursively --- se puede
querer pensar como un pequeño robot --- no puede completar su
trabajo. Eso debe manejar el cálculo para
(triangle-recursively 6) a una segunda instancia del programa,
a un segundo robot. Este segundo individuo es completamente diferente
desde el primero; eso es, en la jerga, una `diferente
instanciación'. O, poner otro camino, eso es un diferente robot. Eso
es el mismo modelo como el primero; eso calcula números de
triángulo recursivamente; pero eso tiene un número de serie diferente.



\textquestiondownY qué hace (triangle-recursively 6)
devuelve? Eso devuelve el número 6 añadido al valor devuelto para
evaluar triangle-recursively con un argumento de 5. Usando la
metáfora del robot, eso cuestiona todavía otro robot
para ayudarle.



Ahora el total es:



 
(+ 7 6 (triangle-recursively 5))




¿Y qué ocurre después?



 
(+ 7 6 5 (triangle-recursively 4))




Cada vez que triangle-recursively es llamado, excepto por la
última vez, eso crea otra instancia del programa --- otro robot ---
y pregunta para crear un cálculo.



Eventualmente, la completa adición es configurado y medido:



 
(+ 7 6 5 4 3 2 1)




Este diseño para la función difiere el cálculo del primer paso
hasta el segundo puede ser hecho, y difiere esto hasta que el tercero
puede ser hecho, y así. Cada defermento significa el
ordenador debe recordar que está siendo esperado dentro. Esto no es
un problema cuando hay solo unos pocos pasos, como en este
ejemplo. Pero eso puede ser un problema cuando hay más pasos.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.3.8 No hay solución pospuesta






La solución al problema de operaciones pospuestas es para escribir
en una manera que no posponga operaciones@footnot{La frase cola
recursiva es usado para describir tal proceso, uno que usa `espacio
constante'.}. Esto requiere escribir a un patrón diferente, con
frecuencia uno que involucra escribiendo dos definiciones de
función, una función de `inicialización' y una función `ayuda'.



La función `inicializactión' configura el trabajo; la función
`ayudante' hace el trabajo.



Aquí hay dos definiciones para añadir números. Son
así de simple, aunque se encuentre duro de comprender.



 
(defun triangle-initialization (number)
  "Devuelve la suma de los número 1 a través de NUMBER inclusive.
Este es el componenete de `inicialización' de una función duo que 
usa recursión"
  (triangle-recursive-helper 0 0 number))




 
(defun triangle-recursive-helper (sum counter number)
  "Devuelve SUM, usando COUNTER, a través de NUMBER inclusive.
Este es el componente `helper' de unas dos funciones
que usan recursión."
  (if (> counter number)
      sum
    (triangle-recursive-helper (+ sum counter)  ; suma
                               (1+ counter)     ; contador
                               number)))        ; número




Instalar ambas definiciones de función por evaluarlo, entonces llama
a triangle-initialization con 2 filas:



 
(triangle-initialization 2)
    ⇒ 3




La función `inicialización' llama la primera instancia de la
función `ayudante' con tres argumentos: cero, cero, y un número
que es el número de filas en el triángulo.



Los primeros dos argumentos pasaron a la función `ayuda' son valores
de inicialización. Estos valores son cambiados cuando
triangle-recursive-helper invocan nuevas
instancias.(12)



Permítase ver que ocurre cuando tenemos un triángulo
que tiene una fila. (\textexclamdownEste triángulo tendrá un
asterisco dentro!)



triangle-initialization llamará su ayudante con los
argumentos 0 0 1. Esta función ejecutará el test
condicional si (> counter number):



 
(> 0 1)




y encuentra que el resultado es falso, así invocará la
else-part de la claúsula if:



 
    (triangle-recursive-helper
     (+ sum counter)  ; sum más counter ⇒ sum
     (1+ counter)     ; incrementa counter ⇒ counter
     number)          ; number parece lo mismo




que computará primero:



 
(triangle-recursive-helper (+ 0 0)  ; sum
                           (1+ 0)   ; counter
                           1)       ; number
que es:

(triangle-recursive-helper 0 1 1)




De nuevo, (> counter number) será falso, así de
nuevo, el intérprete Lisp evaluará
triangle-recursive-helper, creando una nueva instancia con
nuevos argumentos.



Esta nueva instancia será;



 
    (triangle-recursive-helper
     (+ sum counter)  ; suma más contador ⇒ sum
     (1+ counter)     ; incrementar contador ⇒ contador
     number)          ; número empieza lo mismo

que es:

(triangle-recursive-helper 1 2 1)




En este caso, el test (> counter number) será cierto!
Así la instancia devolverá el valor de la suma, que
será 1, como se espera.



Ahora, permite pasar triangle-initialization un argumento de 2,
para encontrar cuantos asterisco hay en un triángulo con dos filas.



Esta función llama (triangle-recursive-helper 0 0 2).



En fases, las instancias llamadas serán:



 
                          suma contador número
(triangle-recursive-helper 0    1       2)

(triangle-recursive-helper 1    2       2)

(triangle-recursive-helper 3    3       2)




Cuando la última instancia se llama, el (> counter number) se
chequea será cierto, así la instancia devolverá el
valor de sum, que será 3.



Este tipo de patrón ayuda cuando estás escribiendo funciones que
puede usar recursos en un ordenador.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




11.4 Ejercicio de Bucles










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12. Búsquedas de Expresiones Regulares









Las búsquedas expresiones regulares son usadas extensivamente en GNU
Emacs. Las dos funciones forward-sentence y
forward-paragraph, ilustra estas búsquedas bien. Ellos usan
expresiones regulares para encontrar donde mover el punto. La frase
`expresión regular' es con frecuencia escrita como `regexp'.



Las búsquedas de expresiones regulares son descritas en
(emacs)Búsqueda de Regexp sección `Búsqueda de Expresión Regular' en El Manual de GNU Emacs, tan bien como en (elisp)Expresiones Regulares sección `Expresiones Regulares' en El Manual de Referencia de GNU Emacs Lisp. Escribiendo
este capítulo, estoy presumiendo que tienes al menos una
intimidad con ellos. El mayor punto para recordar es que las
expresiones regulares te permiten buscar patrones tan bien como para
cadenas literales de caracteres. Por ejemplo, el código en
forward-sentece busca para el patrón de posibles caracteres
que podrían marcar el fin de una frase, y mueve el punto
al otro lado.



Antes de mirar en el código la función forward-sentence, es
valorable considerar que el patrón que marca el fin de una frase
debe estar. El patrón se discute en la siguiente sección;
siguiendo que es una descripción de la expresión regular de
búsqueda, re-search-forward. La función
forward-sentence es descrito en la sección
siguiente. Finalmente, la función forward-paragraph es
descrito en la última sección de este
capítulo. forward-paragraph es una función
compleja que introduce varias funcionalidades.





12.1 La Expresión Regular para sentence-end               La expresión regular para 
                               sentence-end.



12.2 La Función re-search-forward          Muy similar a search-forward.



12.3 forward-sentence           Un ejemplo sencillo de búsqueda con 
                               expresiones regulares.



12.4 forward-paragraph: una Mina de Oro de Funciones          Un ejemplo complejo de alguna cosa.



12.5 Crea tu propio fichero ‘TAGS’                      Cómo crear tu propia tabla ‘TAGS’.



12.6 Revisar  



12.7 Ejercicios con re-search-forward       











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.1 La Expresión Regular para sentence-end




El símbolo sentence-end se asocia al patrón que
marca el fin de una frase. ¿Cuál sería
esta expresión regular?



Claramente, una frase puede ser finalizada por un periodo, una marca
de inicio de interrogación, o una marca de exclamación. Dentro, en
Inglés, solo claúsula que finaliza con uno de estos tres
caracteres debería ser considerado el fin de una
frase. Esto significa que el patrón incluiría el
conjunto de caracteres:



 
[.?!]




Sin embargo, no queremos forward-sentence meramente saltar a un
periodo, una marca de pregunta, o una marca de exclamación, porque
tal caracater podría ser usada en el medio de una
frase. Un periodo, por ejemplo, es usada después de
abreviaciones. Así otra información es necesaria.



De acuerdo a la convención, escribe dos espacios después de cada
frase, pero solo un espacio después de un periodo, una marca de
pregunta, o una marca de exclamación seguida por dos espacios es un
buen indicador de un fin de frase. Sin embargo, en un fichero, los dos
espacios puede en vez de ser un tabulador o el fin de una
línea. Esto significa que la expresión regular
incluiría estos tres ítems como alternativas.



Este grupo de alternativas se parece a esto:



 
\\($\\| \\|  \\)
       ^   ^^
      TAB  SPC




Aquí, samp{$ indica que el fin de la
línea, y yo he apuntado donde el tab y dos espacios
están insertados en la expresión. Ambos están insertados
poniendo los caracteres actuales dentro de la expresión.



Dos barras invertidas, ‘\\’, se requiere antes de los
paréntesis y barras verticales: la primera barra invertida cita la
siguiente barra invertida en Emacs; y el segundo indica que el
siguiente caracter, el paréntesis o la barra vertical, es especial.



También, una frase puede ser seguida por uno o más retornos de
carro, como este:



 
[
]*




Como tabuladores y espacios, un retorno de carro es insertado dentro
de una expresión regular insertándolo literalmente. El asterisco
indica que el <RET> es repetido cero o más veces.



Pero uno frase no consiste solo en un periodo, una marca de pregunta o
una marca de exclamación seguida por espacios apropiados: una marca
de cerrar comillas o cerrar un paréntesis de algún tipo puede
preceder el espacio. En realidad más de uno marca o paréntesis
puede preceder el espacio. Estos requieren una expresión que se
parezca a esto:



 
[]\"')}]*




En esta expresión, el primer ‘]’ es el primer caracter en la
expresión; el segundo caracter es ‘\"’, que está precedido
por un ‘\\’ para contar Emacs el ‘\"’ no es
especial. Los últimos tres caracteres son ‘'’, ‘)’, y ‘}.



Todo esto sugiere que el patrón de la expresión regular para
asociar el fin de una frase sería; y, profundamente, si
se evalúa sentence-end se encuentra que es devuelve el valor
siguiente:



 
sentence-end
     ⇒ "[.?!][]\"')}]*\\($\\|     \\|  \\)[
]*"




(Bien, no en GNU Emacs 22; esto es porque un esfuerzo para crear el
proceso simple y manejar más símbolos y
lenguajes. Cuando el valor de sentence-end es nil,
entonces usa el valor definido por la función sentence-end es
nil, entonces usa el valor definido por la función
sentence-end. (Aquí se usa la diferencia entre un
valor y una función en Emacs Lisp.) La función devuelve un valor
construido desde las variables sentence-end-base,
sentence-end-double-space, sentence-end-without-period,
y sentence-end-without-space. La variable crítica
es sentence-end-base; su valor global es similar a uno descrito
debajo pero también contiene marcas de cita adicionales. Estas
tienen diferentes grados de curvas. La variable
sentence-end-without-period, cuando es verdad, dice a Emacs que
una frase puede finalizar sin un periodo tal como texto en Thai.)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.2 La Función re-search-forward




La función re-search-forward es mucho como la función
search-forward. (Véase la sección  La Función search-forward.)



re-search-forward buscar una expresión regular. Si la
búsqueda es exitosa, deja el punto inmediatamente después del
último caracter en el objetivo. Si la búsqueda es hacia atrás,
eso deja el punto antes del primer caracter en el objetivo. Se puede
contar re-search-forward para devolver t a
cierto. (Moviendo el punto es por ello un `efecto lateral'.)



Como search-forward, la función re-search-forward toma
cuatro argumentos:



    

  1. 
El primer argumento es la expresión regular que la función
busca. La expresión regular será una cadena entre comillas.


  2. 
El segundo argumento opcional limita como de lejos la función
buscará; es un emparejamiento, que es especificado como una
posición en el búffer.


  3. 
El tercer argumento opcional especifica como la función responde al
fallo: nil como el tercer argumento causa la función para
señalar un error (e imprime un mensaje) cuando la búsqueda falla;
cualquier otro valor causa devolver nil si la búsqueda falla
y t si la búsqueda tiene éxito.


  4. 
El cuarto argumento opcional es el contaje repetido. Un contaje
negativo repetido causa re-search-forward para buscar hacia atrás.




La plantilla para re-search-forward se parece a esto:



 
(re-search-forward "regular-expression"
                limit-of-search
                what-to-do-if-search-fails
                repeat-count)




El segundo, tercer, y cuarto argumentos son opcionales. Sin embargo,
si se quiere pasar un valor a uno o ambos de los últimos dos
argumentos, se debe también pasar un valor a todos los argumentos
precedentes. De otro modo, el intérprete Lisp errará a qué
argumento estás pasando el valor.



En la función forward-sentence, la expresión regular será
el valor de la variable sentence-end. En forma simple, esto es:



 
"[.?!][]\"')}]*\\($\\|  \\|  \\)[
]*"




El límite de la búsqueda será el fin del párrafo
(desde una frase no puede ir bajo un párrafo). Si la búsqueda
falla, la función devuelve nil, y el contaje repite será
provisto por el argumento para la función forward-sentence.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.3 forward-sentence




El comando mueve el cursor hacia adelante una frase es una
ilustración honesta de como usar búsquedas de expresiones
regulares en Emacs Lisp. En realidad, la función parece más larga
y más complicada de lo que es; esto es porque la función está
diseñada para ir hacia atrás tan bien como hacia adelante; y,
opcionalmente, a través de una frase. La función está
normalmente asociada al comando M-e.





• forward-sentence completo  



Los bucles while    Dos bucles while.



La búsqueda de expresiones regulares    Una búsqueda de expresión regular.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Completa la definición forward-sentence



Aquí está la código para forward-sentence:



 
(defun forward-sentence (&optional arg)
  "Ve al siguiente `sentence-end'. Con argumento, repite.
Con argumento negativo, mueve atrás repetidamente a `sentence-beginning'.
La variable `sentence-end' es una expresión regular que empareja el
fin de frases. También, cada párrafo asociado las frases tan bien.
  (interactive "p")
  (or arg (setq arg 1))
  (let ((opoint (point))
        (sentence-end (sentence-end)))
    (while (< arg 0)
      (let ((pos (point))
            (par-beg (save-excursion (start-of-paragraph-text) (point))))
       (if (and (re-search-backward sentence-end par-beg t)
                (or (< (match-end 0) pos)
                    (re-search-backward sentence-end par-beg t)))
           (goto-char (match-end 0))
         (goto-char par-beg)))
      (setq arg (1+ arg)))

    (while (> arg 0)
      (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
       (if (re-search-forward sentence-end par-end t)
           (skip-chars-backward " \t\n")
         (goto-char par-end)))
      (setq arg (1- arg)))
    (constrain-to-field nil opoint t)))





La función se ve larga a primera vista y es mejor mirar a su primer
esquéleto, y entonces su músculo. El camino para ver el
esquéleto es mirar en las expresiones que empiezan las columnas
más a la izquierda:



 
(defun forward-sentence (&optional arg)
  "documentation…"
  (interactive "p")
  (or arg (setq arg 1))
  (let ((opoint (point)) (sentence-end (sentence-end)))
    (while (< arg 0)
      (let ((pos (point))
            (par-beg (save-excursion (start-of-paragraph-text) (point))))
       rest-of-body-of-while-loop-when-going-backwards
    (while (> arg 0)
      (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
       rest-of-body-of-while-loop-when-going-forwards
    handle-forms-and-equivalent




\textexclamdownEsto parece bastante simple! La definición de la
función consiste de documentación una expresión
interactive, una expresión or, una expresión
let, y bucles while.



Permite mirar cada una de estas partes.



Notamos que la documentación es profunda y comprensible



La función tiene una declaración interactive "p". Esto
signifca que el argumento prefijo, si cualquiera es pasado a la
función como su argumento. (Esto será un número.) Si la
función no es pasada un argumento (eso es opcional) entonces el
argumento arg será asociado a 1.



Cuando forward-sentence se llame no interacitvamente sin un
argumento, arg está asignado nil. La expresión
or maneja esto. Lo que hace es dejar el valor de arg
como eso es, pero solo si arg está asignado a un valor; o eso
asigna el valor de arg a 1, en el caso de arg está
asignado a nil.



Lo siguiente es un let. Que especifica los valores de dos
variables locales point y sentence-end. El valor local
de punto, desde antes de la búsqueda, es usada en la función
constrain-to-field que maneja formularios y equivalentes. La
variable sentence-end está asignado por la función
sentence-end.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Los bucles while



Sigue dos bucles while. El primer while tiene un
true-or-false-test que chequea cierto si el argumento prefijo para
forward-sentence es un número negativo. Esto para volver
hacia atrás. El cuerpo de este bucle es similar al cuerpo de la
segunda cláusula while, pero eso no es exactamente el
mismo. Se escapará este bucle while y concentra en el segundo
bucle while.



El segundo bucle while está moviendo el punto hacia
adelante. Su esquéleto se parece a esto:



 
(while (> arg 0)            ; true-or-false-test
  (let varlist
    (if (true-or-false-test)
        then-part
      else-part
  (setq arg (1- arg))))     ; while loop decrementer




El bucle while es el tipo de decremento. (@xref{Bucle de
Decremento, , Un Bucle con un Contador de Decremento}.) Eso tiene un
true-or-false-test que chequea cierto tan largo con el contado (en
este caso, la variable arg) es mayor que cero; y eso tiene un
decremento que elimina 1 desde el valor del contador cada vez que el
bucle repite.



Si ningún argumento prefijo es dado para forward-sentece, que
es el camino más común es usado, este bucle while
ejecutará una vez, desde que el valor de arg será 1.



El cuerpo del cuerpo while consite de una expresión
let, que crea y asocia una variable local, y tiene, su cuerpo,
una expresión if.



El cuerpo del bucle while parece esto:



 
(let ((par-end
       (save-excursion (end-of-paragraph-text) (point))))
  (if (re-search-forward sentence-end par-end t)
      (skip-chars-backward " \t\n")
    (goto-char par-end)))




La expresión let crea y asocia la variable local
par-end. Como se ve, esta variable local está diseñado para
proporcionar una asociación o límite para la
búsqueda expresión regular. Si la búsqueda falla para encontrar
una frase apropiada finalizando en el párrafo, eso parará logrando
el fin del párrafo.



Pero primero, permíteno examinar como par-end es
asociado a la variable del fin del párrafo. Qué ocurre es que el
let asigna el valor de par-end al valor devuelto cuando
el intérprete evalúa la expresión.



 
(save-excursion (end-of-paragraph-text) (point))




En esta expresiónd, (end-of-paragraph-text) mueve el punto al
fin del párrafo, (point) devuelve el valor del punto, y
entonces save-excursion restaura el punto a su posición
original. De este modo, el let asocia par-end al valor
devuelto por la expresión save-excursion, que es la
posición del fin del párrafo.  (La función
end-of-paragraph-text usa forward-paragraph, que se
discutirá pronto.)



Emacs evalúa el cuerpo del let, que es una expresión
if que se parece a esto:



 
(if (re-search-forward sentence-end par-end t) ; if-part
    (skip-chars-backward " \t\n")              ; then-part
  (goto-char par-end)))                        ; else-part




El test if si su primer argumento es cierto y si
así, evalúa su parte then; de otro modo, el
intérprete Emacs Lisp evalúa la parte else. El true-or-false-test
de la expresión if es la búsqueda de la expresión regular.



Eso parece mal tener que mirar como el `trabajo real' de la función
forward-sentence cubierta aquí, pero esto es un
camino común este tipo de operación está traida en Lisp.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La búsqueda de expresiones regulares



La función re-search-forward busca el fin de la frase, que
es, para el patrón definido por la expresión regular
sentence-end. Si el patrón es encontrado --- si el fin de la
frase se encuentra --- entonces la función re-search-forward
hace dos cosas:



    

  1. 
La función re-search-forward trae un efecto lateral, que es
mover el punto al fin de la ocurrencia encontrada.


  2. 
La función re-search-forward devuelve un valor de
verdad. Esto es el valor recibido por el if, y significa que la
búsqueda fué exitosa.




El efecto lateral, el movimento de punto, está completado antes de
la función if está manejado el valor devuelto por la
exitosa conclusión de la búsqueda.



Cuando la función if recibe el valor de verdad desde una
llamada exitosa a re-search-forward, el if evalúa la
parte then que es la expresión (skip-chars-backward
"\t\n"). Esta expresión mueva atrás a través de espacios en
blanco, los tabuladores o retornos de carro hasta un caracter impreso
es encontrado y entonces deja el punto correcto después del caracter
impreso cerrado de la frase, que es normalmente un periodo.



Por otro lado, si la función re-search-forward falla para
encontrar un patrón marcando el fin de la frase, la función
devuelve falso. Lo falso causa el if para evaluar su tercer
argumento, que es (goto-char par-end): eso mueve punto para el
fin del párrafo.



(Y si el texto está en una forma o equivalente, y apunta puede no
moverse completamente entonces la función constrain-to-field
empieza a funcionar.)



Las búsquedas de expresiones regulares son excepcionalmente útiles
y el patrón ilustrado por re-search-forward, en el que la
búsqueda es el test de una expresión if, es manejable. Se
verá o escribirá código incorporando este patrón con frecuencia.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.4 forward-paragraph: una Mina de Oro de Funciones





La función forward-paragraph mueve el punto al fin del
párrafo. Eso está normalmente asociado a M-} y hace uso de
un número de funciones que son importantes en sí,
incluyendo let*, match-beginning, y looking-at.



La definición de función para forward-paragraph es
considerablemente mayor que la definición de función para
forward-sentence porque eso funciona con un párrafo, cada
línea del que puede empezar con un prefijo relleno.



Un prefijo lleno consiste en una cadena de caracteres que son repetido
al principio de cada línea. Por ejemplo, en código
Lisp, es una convención para empezar cada línea de un
comentario de párrafo largo con ‘;;; ’. En modo Texto, cuatro
espacios en blanco crea otro prefijo lleno común, creando un
párrafo indentado. (Véase (emacs)Prefijo Relleno sección `Prefijo Relleno' en El Manual GNU Emacs para más información rellenos.)



La existencia de un prefijo lleno significa que además de ser capaz
de encontrar el fin de un párrafo cuyas líneas
empiezan más a la izquierda, la función forward-paragraph
debe ser capaz de encontrar el fin de un párrafo cuando todos o
muchas de las líneas en el búffer empieza con el
prefijo relleno.



Más allá, es algunas veces práctico ignorar un prefijo lleno que
existe, especialmente cuando las líneas en blanco
separen párrafos. Esto es una complicación añadida.





Definición de función forward-paragraph    Partes clave de la definición de la 
                                  función.



La expresión let*  


El bucle while hacia adelante             El bucle while con modo hacia adelante.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Definición de función forward-paragraph



En vez de imprimir toda la función forward-paragraph,
nosotros solo imprimiremos partes de eso. \textexclamdownLee sin
preparación, la función puede estar para desanimar!



En esquema, la función se parece a esto:



 
(defun forward-paragraph (&optional arg)
  "documentation…"
  (interactive "p")
  (or arg (setq arg 1))
  (let*
      varlist
    (while (and (< arg 0) (not (bobp)))     ; backward-moving-code
      …
    (while (and (> arg 0) (not (eobp)))     ; forward-moving-code
      …




Las primeras partes de la función son rutinas: la función lista
argumentos que consisten de un argumento opcional. La documentación sigue.



La letra minúscula ‘p’ en la declaración interactive
significa que el argumento prefijo procesado, si cualquiera, es pasada
a la función, que ocurre si la función se llama dede otra
interactivamente. Este caso fué descrito
pronto. (Véase la sección  La función forward-sentence.) Ahora se logra el fin de la parte familiar
de esta función.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La expresión let*



La siguiente línea de la función
forward-paragraph empieza una expresión let*. Esto es
tan diferente como let. El símbolo es let*
no let.



La forma especial let* es como let excepto que Emacs
asigna cada variable en secuencia, uno después de otro, y variable
en la última parte de la varlist que puede usar de los valores para
que Emacs asigna variable en la parte temprana de la varlist.




(save-excursion en append-to-buffer.)



En la expresión let* en esta función, Emacs asigna un total
de siete variables: opoint, fill-prefix-regexp,
parstart, parsep, sp-parstart, start, y
found-start.



La variable parsep aparece dos veces, primero, para borrar
instancias de ‘^’, y segundo, para manejar prefijos rellenos.



La variable opoint es solo el valor de point. Como se
puede adivinar, eso se usa en una expresión
constrain-to-field, solo como en forward-sentence.



La variable fill-prefix-regexp es asignado al valor devuelto
para evaluar la siguiente lista:



 
(and fill-prefix
     (not (equal fill-prefix ""))
     (not paragraph-ignore-fill-prefix)
     (regexp-quote fill-prefix))




Esta es una expresión cuyo primer elemento es la forma especial
and.



Como se aprendió antes la (véase la sección La función kill-new), la forma especial and evalúa cada uno de
sus argumentos hasta uno de los argumentos y devuelve un valor de
nil en el que el caso de la expresión and devuelve
nil; sin embargo, si ninguno de los argumentos devuelve un
valor de nil, el valor resultante de evaluar el último
argumento es devuelto. (Desde que tal valor no es nil, eso es
considerado verdad en Lisp.) En otras palabras, una expresión
and devuelve un valor de verdad solo si todos sus argumentos
son verdad.




En este caso, la variable fill-prefix-regexp está asociado a
un valor no nil solo si el las siguientes cuatro expresiones
producen un valor true (por ej., un no nil) cuando son
evaluados; de otro modo, fill-prefix-regexp está asociado a
nil.





 fill-prefix


Cuando esta variable es evaluada, el valor del prefijo lleno, si
cualquiera, está devuelto. Si no hay prefijo relleno, la variable
devuelve nil.





 (not (equal fill-prefix "")


Esta expresión chequea si un prefijo lleno es una cadena
vacía, que es, una cadena sin caracteres en eso. Una
cadena vacía no es útil un prefijo relleno.





 (not paragraph-ignore-fill-prefix)


Esta expresión devuelve nil si la variable
paragraph-ignore-fill-prefix ha sido cambiado siendo asignado
un valor de verdad tal como t.





 (regexp-quote fill-prefix)


Este es el último argumento para la forma especial and. Si
todos los argumentos al and son verdaderos, el valor resultante
de evaluar esta expresión será devuelto por la expresión
and y asociado a la variable fill-prefix-regexp,







El resultado de evaluar esta expresión and con éxito es que
fill-prefix-regexp estará asociado al valor de
fill-prefix como fué modificado por la función
regexp-quote. Lo que regexp-quote hace es leer una
cadena y devolver expresión regular que asociará exactamente la
cadena y nada más. Esto significa que fill-prefix-regexp
será asignado a un valor que asociará el prefijo si el prefijo
existe. De otro modo, la variable será asignada a nil.



Las dos variables locales siguientes en la expresión let*
están diseñadas para eliminar instancias de ‘^’ desde
parstart y parsep, las variables locales que indican que
el párrafo empieza y el separador de párrafo. La siguiente
expresión asigna parsep de nuevo. Esto es manejar prefijos
rellenos.



Esta es la configuración que requiere la llamada de la definición
let* en vez de let. El true-or-false-test para el
if depende de si la variable fill-prefix-regexp evalúa
a nil o algún otro valor.



Si fill-prefix-regexp no tiene un valor, Emacs evalúa la
parte else de la expresión if y asocia parsep a su
valor local. (parsep es una expresión regular que asocia lo
que los párrafos separan.)



Pero si fill-prefix-regexp tiene un valor, Emacs evalúa la
parte then de la expresión if y asocia parsep a una
expresión regular que incluye el fill-prefix-regexp como
parte del patrón.



Especificamente, parsep está asignado al valor original del
párrafo separar la expresión regular concatenada con una
expresión alternativa que consiste del fill-prefix-regexp
seguido por espacios en blanco opcionales para el fin de la
línea. El espacio en blanco está definido por
"[ \t]*$".) El ‘\\|’ define esta porción del regexp
como una alternativa a parsep.



De acuerdo a un comentario en el código, la siguiente variable
local, sp-parstart, se usa para buscar, y entonces los dos
finales, start y found-start, se asignan a nil.



Ahora tenemos dentro del cuerpo del let*. La primera parte del
cuerpo del let* trata con el caso cuando la función es dada
un argumento negativo y consiguientemente moviendo hacia
atrás. Nosotros escaparemos esta sección yendo hacia atrás. Se
escapará de esta sección.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




El bucle while hacia adelante



La segunda parte del cuerpo del let* trata con el proceso hacia
adelante. Eso es un bucle while que repite en sí
tan largo como el valor de arg es mayor que cero. En el uso
más común de la funciń el valor del argumento es 1,
así el cuerpo del bucle while es evaluado
exactamente una vez, y el cursor se mueve hacia adelante un párrafo.




Esta parte maneja tres situaciones: cuando punto está entre
párrafos, cuando hay un prefijo lleno y cuando no prefijo lleno.



El bucle while se parece a esto:



 
;; yendo hacia adelante y no al fin del búffer
(while (and (> arg 0) (not (eobp)))

  ;; entre párrafos
  ;; Mueve hacia delante a través de líneas de
  ;; separación...
  (while (and (not (eobp))
              (progn (move-to-left-margin) (not (eobp)))
              (looking-at parsep))
    (forward-line 1))
  ;;  This decrements the loop
  (unless (eobp) (setq arg (1- arg)))
  ;; ... y una línea más
  (forward-line 1)



  (if fill-prefix-regexp
      ;; Hay un prefijo lleno; que sobreescribe parstart;
      ;; vamos adelante línea por línea
      (while (and (not (eobp))
                  (progn (move-to-left-margin) (not (eobp)))
                  (not (looking-at parsep))
                  (looking-at fill-prefix-regexp))
        (forward-line 1))



    ;; No hay prefijo;
    ;; vamos hacia delante caracter por caracter
    (while (and (re-search-forward sp-parstart nil 1)
                (progn (setq start (match-beginning 0))
                       (goto-char start)
                       (not (eobp)))
                (progn (move-to-left-margin)
                       (not (looking-at parsep)))
                (or (not (looking-at parstart))
                    (and use-hard-newlines
                         (not (get-text-property (1- start) 'hard)))))
      (forward-char 1))



    ;; y si no hay prefijo y si no estamos al final
    ;; ir a lo que fué encontrado en la búsqueda de expresiones regulares
    ;; para sp-parstart
    (if (< (point) (point-max))
        (goto-char start))))





Se puede ver que esto un contador de decremento while, usando
la expresión (setq arg (1- arg)) como el que decrementa. Esta
expresión no está lejos desde el while, pero está oculto
en otra macro Lisp, una macro unless. A menos que estemos al
final del búffer --- esot lo que la función eobp determina;
eso es una abreviación de ‘Fin del Buffer P’ --- nosotros
decrementamos el valor de arg por uno.



(Si estamos al fin del búffer, no podemos ir hacia delante más y
el siguiente bucle de la expresión while chequeará falso
desde que el test es un and con (not (eobp)). La
función not significa exactamente como se esperaba; eso es
otro nombre de null, una función que devuelve cierto cuando
su argumento es falso.)



De manera interesante, el bucle cuenta que no está decrementado
hasta que deje el espacio entre párrafos, a menos que vuelva al fin
del búffer o pare viendo el valor local del separados del párrafo.



El segundo while también tiene una expresión
(move-to-left-margin). La función es autoexplicativo. Eso
está dentro de una expresión progn y no el último
elemento de su cuerpo, así es solo invocado para su
efecto lateral, que es mover el punto al margen izquierdo de la
línea actual.




La función looking-at es tambié auto-explicativo; eso
devuelve cierto si el texto después del punto asocia la expresión
regular dada como su argumento.



El resto del cuerpo del bucle se difícil al principio, pero tiene
sentido como tu regresas para comprenderlo.



Primero considera que ocurre si hay un prefijo de relleno:



 
  (if fill-prefix-regexp
      ;; Hay un prefijo lleno; que sobreescribe parstart;
      ;; vamos adelante línea por línea
      (while (and (not (eobp))
                  (progn (move-to-left-margin) (not (eobp)))
                  (not (looking-at parsep))
                  (looking-at fill-prefix-regexp))
        (forward-line 1))




Esta expresión mueve el punto hacia adelante línea por
línea tan lejos como que las cuatro condiciones son ciertas:



    

  1. 
Punto no está al final del búffer.


  2. 
Podemos mover al margen izquierdo del texto y no estar al fin del búffer.


  3. 
El siguiente punto no separa párrafos.


  4. 
El patrón que sigue el punto es la expresión regular prefija rellena.




La última condición puede ser un puzzle, hasta que recuerdes que
punto fué movido al principio de la línea temprana en
la función forward-paragraph. Esto significa que si el texto
tiene el prefijo relleno, la función looking-at se verá.



Considera qué ocurre cuando no hay un prefijo lleno.



 
    (while (and (re-search-forward sp-parstart nil 1)
                (progn (setq start (match-beginning 0))
                       (goto-char start)
                       (not (eobp)))
                (progn (move-to-left-margin)
                       (not (looking-at parsep)))
                (or (not (looking-at parstart))
                    (and use-hard-newlines
                         (not (get-text-property (1- start) 'hard)))))
      (forward-char 1))




El bucle while nos tiene buscando hacia adelante para
sp-parstart, que es la combianción de posibles espacios en
blanco con un valor local del comienzo de un párrafo o de un
párrafo separador. (Las últimas dos son con una expresión
empezando con (?:) así que no están
referenciadas por la función match-beginning.)



Las dos expresiones,



 
(setq start (match-beginning 0))
(goto-char start)




significa ir al comienzo del siguiente texto localizado por la
expresión regular.



La expresión (match-beginning 0) es nueva. Eso devuelve un
número especificando la posición del comienzo del texto fuese
asociado a la última búsqueda.



La función match-beginning es usado aquí porque
una característica de una búsqueda hacia adelante: una
búsqueda hacia adelante, sin dignidad si eso es una búsqueda plana
o una expresión regular, mueve el punto al fin del texto que es
encontrado. En este caso, una búsqueda exitossa mueve el punto al
fin del patrón para sp-parstart.



Sin embargo, se quiere poner el punto al fin del actual párrafo, no
en algún lugar más. En vez de eso, desde que la búsqueda
posiblemente incluye el separador del párrafo, el punto puede
finalizar al principio de lo siguiente a menos que se use una
expresión que incluya match-beginning.




Cuando un argumento de 0, match-beginning devuelve la posiciń
que es el comienzo del texto asociado por la búsqueda más
reciente. En este caso, la búsqueda más reciente parece
sp-parstart. La expresión (match-beginning 0) devuelve
la posición del comienzo de este patrón, en vez de la posición
final de este patrón.



(Incidentalmente, cuando se pasa un número positivo como un
argumento, la función match-beginning devuelve la
localización de punto en el que la expresión con paréntesis en
la última búsqueda a menos que la expresión con paréntesis
empiece con \(?:. No sé porque \(?: aparece
aquí desde que el argumento es 0.)



La última expresión cuando no hay prefijos es



 
(if (< (point) (point-max))
    (goto-char start))))




Esto dice que si no hay prefijo lleno y no estamos al punto final
movería al principio de lo que fué encontrado por la
búsqueda de la expresión regular para sp-parstart.



La definición completa para la función forward-paragraph no
solo incluy código para avanzar, pero también código para retroceder.



Si estás leyendo esto dentro de GNU Emacs y quieres ver la función
completa, se puede escribir C-h f (describe-function) y
el nombre de la función. Esto te da la documentación de función
y el nombre la librería conteniendo las fuentes de la
función. Posiciona el punto a través del nombre de la
librería y presionar la tecla RET; será tomado
directamente a las fuentes. (\textexclamdownAsegúrate de instalar las
fuentes! \textexclamdownSin
eso, estarás como una persona que intenta conducir un coche con sus
ojos cerrados!)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.5 Crea tu propio fichero ‘TAGS’





Bajo C-h f (describe-function), otro camino para ver la
fuente de una función es escribir @kdb{M-.} (find-tag) y el
nombre de la función se asigna para eso. Esto es un buen hábito
para obtenerlo. El comando M-. (find-tag) toma
directamente a las fuentes de una función, variable, o nodo. La
función depende de tablas de etiquetas para contarlo donde ir.



Si la función find-tag pregunta primero por el nombre de una
tabla ‘TAGS’, dado el nombre de un fichero ‘TAGS’ tal como
‘/usr/local/src/emacs/src/TAGS’. (La ruta exacta a tu fichero
‘TAGS’ depende de como se tu copia de Emacs fué instalada. Yo
te cuento la localización que provee tanto mi C y mis fuentes de
Emacs Lisp.)



Puedes también crear tu propio fichero ‘TAGS’ para los directorios
que faltan.



Con frecuencia se necesita construir e instalar etiquetas de tablas
por tí mismo. Esas no son construidas
automáticamente. Una tabla de etiquestas llama un fichero
‘TAGS’; el nombre es letras mayúsculas.



Se puede crear un fichero ‘TAGS’ llamando el programa
etags que viene como parte de la distribución
Emacs. Normalmente, etags está compilado e instalado cuando
Emacs se construye. (etags no es una función Lisp o una parte
de Emacs; eso es un programa C.)



Para crear fichero ‘TAGS’, primero camibia la directorio en el
que se quiere crear el fichero. En Emacs se puede hacer esto con el
comando M-x cd, o visitando un fichero en el directorio, o
listando el directorio etags *.el como el comando para ejecutar



 
M-x compile RET etags *.el RET




crear un fichero de ‘TAGS’ para Emacs Lisp.



Por ejemplo, si tu tienes un número largo de ficheros en tu
directorio ‘~/emacs’, como se hace --- Yo tengo 137 ‘.el’
dentro, de que se carguen 12 --- se puede crear un fichero ‘TAGS’
para los ficheros Emacs Lisp en este directorio.



El programa etags toma todo la consola usual `comodines'. Por
ejemplo, si tienes dos directorios para el que quieres un fichero
‘TAGS’ simple, escribe etags *.el ../elisp/*.el, donde
‘../elisp/’ es el segundo directorio:



 
M-x compile RET etags *.el ../elisp/*.el RET




Tipo



 
M-x compile RET etags --help RET




para ver una lista de las opciones aceptadas por etags tan bien
como una lista de lenguajes soportados.



El programa etags maneja más de 20 lenguajes, incluyendo
Emacs Lisp, Common Lisp, Scheme, C, C++, Ada, Fortran, HTML, Java,
LaTeX, Pascal, Perl, Postscript, Python, TeX, Texinfo, makefiles, y la
mayoría de ensambladores. El programa no cambia para
especificar el lenguaje; eso reconoce el lenguaje como una entrada de
fichero de acuerdo a su nombre de fichero y contenidos.



‘etags’ es muy útil cuando se escribe código por
tí mismo y quiere referirse a funciones que ya se han
escrito. Ahora ejecuta etags de nuevo en intervalos como se
escriben nuevas funciones, así llegan a ser parte del
fichero ‘TAGS’.



Si piensa que un fichero ‘TAGS’ apropiado que ya existe para lo
que quieres, pero no conoces donde está, se puede usar el programa
locate para intentar encontrarlo.



Escribe M-x locate <RET> TAGS <RET> y Emacs
listará para ti las rutas nombres completas de todos tus ficheros
‘TAGS’. En mi sistema, este comando lista 34 fichero ‘TAGS’.
Por otro lado, un sistema `vanilla plano' que recientemente no
contenía fichero ‘TAGS’.



Si la tabla de etiquetas que se quiere ha sido creada, se puede usar
el comando M-x visit-tags-table para especificarlo. De otro
modo, se necesitará la tabla de etiquetas por tí mismo
y entonces usar M-x visit-tags-table.




Construyendo Etiquetas en las fuentes Emacs






Las fuentes GNU Emacs vienen con un ‘Makefile’ que contiene un
comando sofisticado etags que crea, recoge, y asocia tablas de
etiquetas desde todo a través de las fuentes de Emacs y pone la
información dentro de un fichero ‘TAGS’ en el directorio
‘src/’. (El directorio ‘src/’ está debajo del alto nivel
de tu directorio Emacs.)



Para construir este fichero ‘TAGS’, ir al alto nivel de
directorio de fuentes Emacs y ejecutar comando de compilar make tags:



 
M-x compile RET make tags RET




(El comando make tags trabaja bien con las fuentes de GNU
Emacs, tan bien como con otros paquetes fuentes.)



Para más información, mira (emacs)Etiquetas sección `Tablas de Etiquetas' en El Manual GNU Emacs.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.6 Revisar



Aquí hay un breve resumen de algunas funciones
introducidas recientemente.





 mientras


Repetidamente evalúa el cuerpo de la expresión tan larga como el
primer elemento del cuerpo chequea cierto. Entonces devuelve
nil. (La expresión es evaluado solo por sus efectos laterales.)



Por ejemplo:



 
(let ((foo 2))
  (while (> foo 0)
    (insert (format "foo is %d.\n" foo))
    (setq foo (1- foo))))

     ⇒      foo is 2.
             foo is 1.
             nil




(La función insert inserta sus argumentos en el punto; la
función format devuelve una cadena formateada desde sus
argumentos el camino message formatea sus argumentos; \n
produce una nueva línea.)





 re-search-forward


Busca un patrón, y si el patrón se encuentra, mueve el punto al
resto solo después de eso.



Toma cuatro argumentos, como search-forward:



    

  1. 
Una expresión regular que especifica el patrón para
buscarlo. (\textexclamdownRecuerda por marcas de comillas alrededor de este
argumento!)


  2. 
Opcionalmente, el límite de la búsqueda.


  3. 
Opcionalmente, que haces si la búsqueda falla, devuelve nil o
un mensaje de error.


  4. 
Opcionalmente, cuantas veces repetir la búsqueda; si negativa, la
búsqueda va hacia atrás.






 let*


Asocia algunas variables localmente a valores particulares, y entonces
evalúa los argumentos que permanencen, devolviendo el valor del
último. Mientras se asocian las variables locales, se usan los
valores locales de variables asociadas pronto, si acaso.



Por ejemplo:



 
(let* ((foo 7)
      (bar (* 3 foo)))
  (message "`bar' is %d." bar))
     ⇒ `bar' is 21.






 match-beginning


Devuelve la posición del principio del texto encontrado por la
última búsqueda de la expresión regular.





 looking-at


Devuelve t para verdadero si el texto después del punto se
asocia al argumento, que debería ser una expresión.





 eobp


Devuelve t para cierto si el punto está en el fin de la parte
accesible de un búffer. El fin de la parte accesible es el fin del
búffer no está encogido; eso es el fin de la parte encogida si el
búffer está encogido.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




12.7 Ejercicios con re-search-forward










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




13. Contando: Repetición y Regexps





Repetición y búsquedas de expresiones regulares son herramientas
poderosas que con frecuencia usan cuando escribes código en Emacs
Lisp. Este capítulo ilustra el uso de búsquedas de
expresiones regulares a través de la construcción de comandos de
contaje de palabras usando while bucles y recursión.





• Por qué Contar Palabras  



13.1 La Función count-words-region         Usa un regexp, pero encuentra un problema.



13.2 Cuenta Palabras Recursivamente      Empezar con caso de no palabras en región.



13.3 Ejercicio: Contando Puntuación        











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Contando palabras



La distribución de Emacs estándar contiene una función para
contar el número de líneas con una región. Sin
embargo, no hay función correspondiente para contar palabras.



Cierto tipo de pregunta escrita para contar palabras. De este modo, si
se escribe un ensayo, puede estar limitado 800 palabras; si se escribe
una novela, te puedes disciplinar a ti mismo a escribir 1000 palabras
al día. Parece erróneo para mi que a Emacs la falta un
comando de contar palabras. Quizás la gente usa Emacs
mayoritariamente para codificar o tipos de documentación que no
requiere contar palabras, o quizás eso les restringe al sistema
operativo el comando de contar palabras, wc. De manera
alternativa, la gente puede seguir la convención de las editoriales
y computar un contaje de palabras dividiendo el número de caracteres
en un documento por cinco. En cualquier evento, aquí hay
comandos para contar palabras.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




13.1 La Función count-words-region




Un comando de contar palabras podría contar palabras en
una línea, párrafo, región, o
buffer. ¿Qué comando funcionaría? Se
podría diseñar el comando para contar el número de
palabras en un buffer completo. Sin embargo, la tradición Emacs
anima a la flexibilidad --- se puede querer contar palabras solo en
una sección, en vez de en todo un buffer. Así, tiene
más sentido diseñar el comando para contar el número de palabras
en una región. Una vez tienes un comando count-words-region,
se puede, si lo deseas, contar palabras en un buffer completo
marcándolo con C-x h (mark-whole-buffer).



Claramente, contar palabras es un acto repetitivo: empezando desde el
principio de la región, se cuentas la primera palabra, entonces la
segunda palabra, entonces la tercera palabra, y así,
hasta que logres el fin de la región. Esto significa que contar
palabra es idealmente ajustado a recursión o a un bucle while.





Diseñando count-words-region    La definición usando un bucle 
                                    while.



13.1.1 El Error de Espacio en Blanco en count-words-region  










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Diseñando count-words-region



Primero, implementaremos el comando de contar palabras con un bucle
while, entonces con la recusión. El comando, de acuerdo,
será interactivo.



La plantilla para una definición de función interactiva es, como
siempre:



 
(defun name-of-function (argument-list)
  "documentation…"
  (interactive-expression…)
  body…)




Lo qué necesitamos hacer es rellenar los slots.



El nombre de la función sería auto-explicativo y
similar al nombre del count-lines-region existente. Esto hace
el nombre fácil para recordar. count-words-region es una
buena elección.



La función cuenta palabras con una región. Esto significa que el
argumento lista debe contener símbolos que son asociados
a las dos posiciones, el principio y fin de la región. Estas dos
posiciones puede ser llamadas ‘beginning’ y ‘end’
respectivamente. La primera línea de la documentación
sería una frase simple, desde que esto es todo lo que
está impreso como documentación por un comando tal como
apropos. La expresión interactiva será de la forma
‘(interactive "r")’, desde que causará que Emacs pase al
principio y fin de la región a la lista de argumentos de
función. Todo esto es rutina.



El cuerpo de la función necesita ser escrita para hacer tres tareas:
primero, configurar condiciones bajo la que el bucle while
pueda contar palabras, segundo, ejecutar el bucle while, y
tercero, enviar un mensaje al usuario.



Cuando un usuario llama a count-words-region, apunta a que
puede al principio o fin de la región. Sin embargo, el proceso de
conteo debe empezar al principio de la región. Esto significa que
querremos poner punto si eso no está allí. Esto
significa que querremos poner el punto que hay si eso no está
allí. Ejecutando (goto-char beginning) asegura
esto. De acuerdo, querremos devolver el punto a su posición esperada
cuando la función finalice su trabajo. Por esta razón, el cuerpo
debe ser encerrado en una expresión save-excursion.



La parte central del cuerpo de la funciń consiste en un bucle
while en el que una expresión salta el punto hacia delante
palabra por palabra, y otra expresión cuenta estos saltos. El
true-or-false-test del bucle while chequería
verdadero tan largo como el punto saltaría hacia
adelante, y falso cuando el punto esté al fin de la región.



Nosotros podríamos usar (forward-word 1) como la
expresión para mover el punto hacia adelante palabra por palabra,
pero eso es fácil de ver que Emacs identifica como una `palabra' si
se usa una búsqueda expresión regular.



Una expresión regular busca lo que encuentra el patrón para el que
eso está buscando deja el punto después del último caracter
emparejado. Esto significa que una sucesión de palabras exitosas
busquen que moverá el punto adelante palabra por palabra.



Como una materia práctica, se quiere que la expresión regular
busca para saltar a través de un espacio en blanco y puntuación
entre palabras tan bien a través de las palabras en
sí. \textexclamdownUna expresión regexp que rechaza
para saltar a través de espacios en blanco entre palabras nunca
saltaría más de una palabra!. Esto significa que el
regexp incluiría el espacio en blanco y la puntuación
que sigue a una palabra, si cualquiera, como la palabra en
sí. (Una palabra puede finalizar un búffer y no tiene
cualquier espacio en blanco o puntuación, así esta
parte del regexp debe ser opcional.)



De este modo, que queremos para el regexp es un patrón definiendo
una o más palabras caracteres que constituyen caracteres seguidos,
opcionalmente, por uno o más caracteres que no son palabras
consituyentes. La expresión regular para esto es:



 
\w+\W*




La tabla de sintaxis del búffer determina qué caracteres son y no
son palabras constituyentes. (@xref{Sintaxis, , @questiondown{}Qu@'e
Constituye una Palabra o S@'{@dotless{i}}mbolo?}, más acerca de
sintaxis. También, ver Sintaxis: (emacs)Sintaxis sección `La Tabla de Sintaxis' en El Manual de GNU Emacs, y (elisp)Tablas de Sintaxis sección `Tablas de Sintaxis' en El Manual de Referencia de GNU Emacs Lisp.)



La expresión se parece a esto:



 
(re-search-forward "\\w+\\W*")




(Note que las barras invertidas que preceden el ‘w’ y
‘W’. Una barra invertida tiene significado especial al
intérprete Emacs Lisp. Eso indica que el caracter siguiente es
interpretado de manera diferente que la normal. Por ejemplo, los dos
caracteres, ‘\n’, son una ‘nueva línea’, en
vez de una barra invertida seguida por ‘\n’. Dos barras
invertidas en una fila para una `barra invertida no especial',
así Emacs Lisp interpreta el fin de mirar una barra
invertida simple seguida por una letra. Así descubre la
letra que es especial.)



Se necesita un contador para contar cuantas palabras hay; esta
variables debe primero ser asignado a 0 y entonces incrementados cada
vez que Emacs va alrededor del bucle while. La expresión de
incremento es simple:



 
(setq count (1+ count))




Finalmente, se quiere contar al usuario cuantas palabras hay en la
región. La función message se pretende para presentar este
tipo de información al usuario. El mensaje tiene que ser fraseado
así que lee apropiadamente sin cuidado cuantas palabras
hay en la región: no queremos decir que ``hay una palabra en la
regiń''. El conflicto entre singular y plural es no gramatical. Se
puede resolver este problema usando una expresión condicional que
evalúa diferentes mensajes dependiendo en el número de palabras en
la región. Hay tres posibilidades: no palabras en la región, una
palabra en la región, y más de una palabra. Esto significa que la
forma especial cond es apropiado.



Todo esto lidera a la siguiente definición de función:



 
;;; \textexclamdownLa Primera versión; tiene errores!
(defun count-words-region (beginning end)
  "Imprime el número de palabras en la región.
Las palabras están definidas al menos una palabra
constituida de caracteres seguido por al menos un 
caracter que no constituye palabra. La tabla de 
sintaxis del búffer determina qué caracteres hay."
  (interactive "r")
  (message "Contando palaras en la región ... ")



;;; 1. Configurar condiciones apropiadas.
  (save-excursion
    (goto-char beginning)
    (let ((count 0))



;;; 2. Ejecutar el bucle while.
      (while (< (point) end)
        (re-search-forward "\\w+\\W*")
        (setq count (1+ count)))



;;; 3. Enviar un mensaje al usuario.
      (cond ((zerop count)
             (message
              "La región no tiene palabras."))
            ((= 1 count)
             (message
              "The región tiene 1 palabra."))
            (t
             (message
              "The región tiene %d palabras." count))))))




Como se escribe, la función funciona, pero no en todas las circunstancias.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




13.1.1 El Error de Espacio en Blanco en count-words-region



El comando count-words-region descrito en las secciones
precedentes tienen dos errores, o incluso, un error con dos
manifestaciones. Primero, si tu marcas una región conteniendo solo
espacio en blanco en el medio de algún texto el comando
count-words-region cuenta que la región contiene un
palabra. Segundo, si se marca una región conteniendo solo espacios
en blanco al final del búffer o la porción accesible de un buffer
encogido, el comando muestra un mensaje de error que se parece a esto:



 
Búsqueda fallida: "\\w+\\W*"




Si estás leyendo esto en Info en GNU Emacs, se puede testear para
estos errores por sí mismo.



Primero, evalúa la función en la manera usual para instalarlo.



Si lo desea, se puede también instalar este atajo para evaluarlo:



 
(global-set-key "\C-c=" 'count-words-region)




Para conducir el primer test, asigna marca y punto al principio y fin
de la siguiente línea y entonces escribe C-c = (o
M-x count-words-region si no has asignado C-c =):



 
    uno   dos  tres




Emacs te contará, correctamente, que la región tiene tres palabras.



Repite el test, pero marca el lugar al principio de la
línea y emplaza el punto justo antes de la
palabra ‘uno’. De nuevo escribe el comando C-c = (o
M-x count-words-region). Emacs contaría que la
región no tiene palabaras, desde que eso está compuesto solo por
espacios en blanco al principio de la
línea. \textexclamdownPero en vez de que Emacs cuente
que la región tiene una palabra!



Para el tercer test, copia la línea de ejemplo al fin
del buffer ‘*scratch*’ y entonces escribe varios espacios al fin
de la línea. Posiciona la marca correcta después de la
palabra ‘tres’ y apunta la fin de la línea. (El fin
de la línea será el fin del buffer.) Escribe C-c
= (o M-x count-words-region) como se hizo antes. De nuevo,
Emacs te contaría que la regiones no tienen palabras,
desde que eso está compuesto solo de los espacios en blanco al fin
de la línea. En vez de eso, Emacs muestra un mensaje de
error diciendo ‘Búsqueda fallida’.



Los dos errores queman el mismo problema.



Considera la primera manifestación del error, en el que el comando
te cuenta que el espacio en blanco al principio de la
línea contiene una palabra. Lo que ocurre es esto: El
comando M-x count-words-region mueve el punto al principio de
la región. El test while si el valor del punto es más
pequeño que el valor de end, que es. Por consiguiente, en la
expresión regular se busca y encuentra la primera palabra. Eso deja
el punto después de la palabra. count es establecido a
uno. El bucle while repite; pero esta vez el valor del punto es
más largo que el valor de end, el bucle sale; y la función
muestra un mensaje diciendo el número de palabras en la región es
uno. En breve, la expresión regular busca y encuentra la palabraa
incluso aunque eso está fuera de la región marcada.



En la segunda manifestación del error, la región es un espacio en
blanco al fin del búffer. Emacs dice ‘Búsqueda fallida’. Lo
que ocurre es que true-or-false-test en el bucle while chequea
verdad, así la expresión de búsqueda es
ejecutada. Pero desde que no hay más palabras en el buffer, la
búsqueda falla.



En ambas manifestaciones del error, la búsqueda extiende o intenta
extendeer fuera de la región.



La solución es limitar la búsqueda a la región --- esto es una
acción simple y limpia, pero como tu puedes tener que llegar a
esperar, eso no es bastante simple como tu podrías pensar.



Como se ha visto, la función re-search-forward toma un
patrón de búsqueda como su primer argumento. Pero además a este
primer, argumento obligatorio, eso acepta tres argumentos
opcionales. El segundo argumento opcional asocia la búsqueda. El
tercer argumento opcional, si t, causa la función a devolver
nil en vez de la señal un error si la búsqueda falla. El
cuarto argumento opcional es un contador repetido. (En Emacs, se puede
ver una documentación de la función escribiendo C-h f, el
nombre de la función, y entonces <RET>.)



En la definición count-words-region, el valor del fin de la
región es tomada por la variable end que es pasado como un
argumento para la función. De este modo, se puede añadir
end como un argumento para la búsqueda de la expresión regular.



 
(re-search-forward "\\w+\\W*" fin)




Sin embargo, si se crea solo este cambio a la definición
count-words-region y entonces chequea la nueva versión de la
definición en extender un espacio en blanco, se recibirá un
mensaje de error diciendo ‘Búsqueda fallida’.



Lo que ocurre es esto: la búsqueda es limitada a la región, y
falla como se espera porque no hay caracteres de palabras
constituyentes en la región. Desde que eso falla, se recibe un
mensaje de error. Pero no queremos recibir un mensaje de error en este
caso; se quiere recibir el mensaje que "La región no tiene palabras".



La solución a este problema es proveer re-search-forward con
un tercer argumento de t, que causa la función para devolver
nil en vez la señalar un error si la búsqueda falla.



Sin embargo, si se crea este cambio y se intenta, se verá el mensaje
``Contando palabras en la región ...'' y … se guardará
viendo que mensaje …, hasta se escribe C-g
(keyboard-quit).



Aquí está lo que ocurre: la búsqueda está limitada
a la región, como antes, y eso falla porque no hay caracteres no
constituyentes de palabras en la región, como se
espera. Consiguientemente, la expresión re-search-forward
devuelve nil. Eso no hace nada más. En particular, no mueve
el punto, que hace como un efecto lateral si eso encuentra la
búsqueda objetiva. Después la expresión re-search-forward
devuelve nil, la siguiente expresión en el bucle while
está evaluado. Esta expresión incrementa el contador. Entonces el
bucle repite. El test true-or-false-test chequea verdad porque el
valor del punto es todavía menor que el valor final,
desde que la expresión re-search-forward no
movería el punto. … y el ciclo repite …



La definición count-words-region requiere
todavía otra modificación para causar el
true-or-false-test del bucle while para chequear falso si la
búsqueda falla. Pon otro camino, hay dos condiciones que deben ser
satisfechas en el true-or-false-test antes que el contador de palabras
variable se incremente: punto debe todavía estar con la
región y la expresiń de búsqueda debe haber encontrado una
palabra para contar.



Desde ambos la primera condición y la segunda condición debe ser
cierta juntos, las dos expresiones, la región chequea y la
expresión de búsqueda, puede estar unido con una forma especial
and y embebido en el bucle while como el
true-or-false-test, como esto:



 
(and (< (point) end) (re-search-forward "\\w+\\W*" end t))





La expresión re-search-forward devuelve t si la
búsqueda exitosa y como efecto lateral mueve el
punto. Consiguientemente, como palabras son encontradas, el punto es
movido a través de la región. Cuando la búsqueda expresión
falla para encontrar otra palabra, o cuando el punto logra el fin de
la región, el test true-or-false-test falso, el bucle while
existe, y la función count-words-region muestra uno u otro de
sus mensajes.



Después de incorporar estos cambios finales, el
count-words-region funciona sin errores (\textexclamdowno al
menos, sin los errores que yo encontré!. Aquí está
lo que parece:



 
;;; Final versión: while
(defun count-words-region (beginning end)
  "Imprime número de palabras en la región."
  (interactive "r")
  (message "Contando palabras en la región ... ")



;;; 1. Configura condiciones apropiadas.
  (save-excursion
    (let ((count 0))
      (goto-char beginning)



;;; 2. Ejecuta el bucle while
      (while (and (< (point) end)
                  (re-search-forward "\\w+\\W*" end t))
        (setq count (1+ count)))



;;; 3. Enviar un mensaje al usuario.
      (cond ((zerop count)
             (message
              "La región no tiene palabras."))
            ((= 1 count)
             (message
              "The región tiene 1 palabra."))
            (t
             (message
              "The región tiene %d palabras." count))))))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




13.2 Cuenta Palabras Recursivamente






Se puede escribir la función para contar palabras recursivamente tan
bien como con un bucle while. Permite ver cómo es hecho.



Primero, se necesita reconocer que la función
count-words-region tiene tres trabajos: eso configura las
condiciones apropiadas para contar lo que ocurre; eso cuenta las
palabras en la región; y envía un mensaje al usuario
contando cuantas palabras hay.



Si se escribe una función recursiva simple para hacer cualquier cosa
se recibirá un mensaje para cada llamada recusiva. Si la región
contiene 13 palabras, se recibirán trece mensajes, uno correcto
después del otro. \textexclamdownNo queremos esto!. En vez de eso,
se deben escribir dos funciones para hacer el trabajo, una (la
función recursiva) será usada dentro de la otra. Una función
configurará las condiciones y muestra el mensaje; la otra
devolverá el contador de palabras.



Permítenos comenzar con la función que causa el
mensaje que será mostrado. Se puede continuar a llamar este
count-words-region.



Esta es la función que el usuario llamará. Será interactivo. En
realidad, será similar a nuestras versiones previas de esta
función, excepto que llamará recursive-count-words para
determinar cuantas palabras hay en la región.



Se puede construir una plantilla legible para esta función, basado
en versiones previas:



 
;; Versión Recursiva; usa la búsqueda de la expresión regular
(defun count-words-region (beginning end)
  "documentation…"
  (interactive-expression…)


;;; 1. Configura condiciones apropiadas.
  (explanatory message)
  (set-up functions…


;;; 2. Contar las palabras.
    recursive call


;;; 3. Enviar un mensaje al usuario.
    message providing word count))




La definición parece sencillo, excepto que como el contador devuelve
la llamada recursiva que debe ser pasada al mensaje mostrando el
contaje de palabras. Un pequeño pensamiento sugiere que esto puede
ser hecho haciendo uso de una expresión let al número de
palabras en la región, como se devuelve por la llamada recursiva; y
entonces la expresión cond, usando la asociación, puede
mostrar el valor al usuario.



Con frecuencia, uno piensa que asociar una expresión let como
secundario al trabajo `primario' de una función. Pero en este caso,
que podría considerar el trabajo `primario' de la
función, contando palabras, es hecho con la expresión let.



Usando let, la definición de función se parece a esto:



 
(defun count-words-region (beginning end)
  "Imprime el número de palabras en la región."
  (interactive "r")



;;; 1. Configura condiciones apropiadas.
  (message "Contando palabras en la región ... ")
  (save-excursion
    (goto-char beginning)



;;; 2. Contar las palabras.
    (let ((count (recursive-count-words end)))



;;; 3. Enviar un mensaje al usuario.
      (cond ((zerop count)
             (message
              "La región no tiene palabras."))
            ((= 1 count)
             (message
              "The región tiene 1 palabra."))
            (t
             (message
              "The región tiene %d palabras." count))))))




Lo siguiente, que se necesita es escribir la fución de contaje recursivo.



Una función recrsiva tiene al menos tres partes: el `do-again-test',
la `next-step-expression', y la llamada recursiva.



El do-again-test determina si la función será o no llamado de
nuevo. Desde que estamos contando palabras en una región y puede
causar una función que mueva el punto hacia delante por cada
palabra, el do-again-test puede chequear si el punto está
todavía con la región. El do-again-test
encontraría el valor del punto y determina si el punto
está antes, en, o después del valor del fin de la región. Se
puede usar la función point localizar el punto. Claramente,
se debe pasar el valor del fin de la región a la función de
contaje recursivo como un argumento.



Además, el do-again-test también chequearía si la
búsqueda encuentra una palabra. Si no, la función no se
llamaría de nuevo.



La next-step-expression cambia un valor así que cuando
la función recursiva se supone que debe parar de llamarse
así misma, eso para. Más precisamente, los cambios de
next-step-expression cambia un valor así que en el
momento adecuado, el do-again-test para la función recursiva de la
llamada en sí de nuevo. En este caso, la
next-step-expression puede ser la expresión que mueve el punto hacia
adelante, palabra por palabra.



La tercera parte de una función recursiva es la llamada recursiva.



En algún lugar, también, se necesita una parte que hace el
`trabajo' de la función, una parte que el
contaje. \texclamdownUna parte vital!



Pero ya, tenemos un guión del la función recursiva de contaje:



 
(defun recursive-count-words (region-end)
  "documentation…"
   do-again-test
   next-step-expression
   recursive call)




Ahora se necesita rellenar los slots. Permite comenzar con el caso
más simple primero: si se apunta debajo del fin de la región, no
puede haber palabras en la región, así la función
devuelve cero. De otro modo, si la búsqueda falla no hay palabras
para contar, así la función devolvería cero.



Por otro lado, si se apunta con la región y la búsqueda tiene
éxito, la función se llamaría de nuevo.



De este modo, do-again-test se vería como esto:



 
(and (< (point) region-end)
     (re-search-forward "\\w+\\W*" region-end t))




Note que la expresión de búsqueda es parte del do-again-test ---
la función devuelve t si su búsqueda tiene éxito y
nil falla. (@xref{Error de Espacio en Blanco, , El Error de
Espacio en Blanco en @code{count-words-region}}, para una
explicación de como re-search-forward funciona.)



El do-again-test es el test true-or-false de una cláusula
if. Claramente si el do-again-test tiene éxito, la then-part
de la cláusula if llamaría la función; pero
si eso falla, la else-part devolvería cero desde que el
punto está fuera de la región o la búsqueda fallón por no
había palabras a encontrar.



Pero antes de considerar la llamada recursiva, se necesita considerar
la next-step-expression. ¿Qué es eso? De manera
interesante, eso es la parte de la búsquede del do-again-test.



Además para devolver t o nil para el do-again-test,
re-search-forward mueve el punto hacia adelante como un efecto
lateral de un búsqueda exitosa. Esta es la acción que cambia el
valor de punto así que la función recursiva para de
llamarse a sí mismo cuando el punto complete su
movimiento a través de la región. Por consiguiente, la expresión
re-search-forward es la next-step-expression.



En esquema, entonces, el cuerpo de la función
recursive-count-words se parece a esto:



 
(if do-again-test-and-next-step-combined
    ;; then
    recursive-call-returning-count
  ;; else
  return-zero)




¿Cómo incorporar el mecanismo que cuenta?



Si no estas acostumbrado a escribir funciones recursivas, una pregunta
como esta puede ser un problema. Pero eso puede y sería
enfocado sistemáticamente.



Se sabe que el mecanismo de contaje sería asociado en
algún lugar con la llamada recursiva. En vez, desde que la
next-step-expression mueve el punto hacia adelante por una palabra, y
desde que una llamada recursiva es hecha para cada palabra, el
mecanismo de contaje debe ser una expresión que añade uno al valor
devuelto por una llamada para recursive-count-words



Considera varias casos:





Desde el esquema podemos ver que la parte else del if devuelve
cero para el caso de no palabras. Esto significa que la parte then del
if debe devolve un valor resultante de añadir uno al valor
devuelto desde contado de la palabras que permanecen.



La expresión se parece a esto, donde 1+ es una función que
añade uno a su argumento.



 
(1+ (recursive-count-words region-end))




La función completa recursive-count-words entonces se
parecerá e esto:



 
(defun recursive-count-words (region-end)
  "documentation…"

;;; 1. do-again-test
  (if (and (< (point) region-end)
           (re-search-forward "\\w+\\W*" region-end t))



;;; 2. then-part: la llamada recursiva
      (1+ (recursive-count-words region-end))

;;; 3. else-part
    0))




Permíteme examina como esto funciona:



Si no hay palabras en la región, la parte else de la expresión
if es evaluada y consecuentemente la función devuelve cero.



Si hay una palabra en la región, el valor del punto es menor que el
valor de region-end y la búsqueda tiene éxito. En este
caso, el true-or-false-test de la expresión if chequea
cierto, y la then-part de la expresión if es evaluada. La
expresión de contaje es evaluada. Esta expresión devuelve un valor
(que será el valor devuelto por la función completa) que es la
suma de uno añadida al valor devuelto por una llamada recursiva.



Mientras tanto, la next-step-expression ha causado el punto para salta
a través del primero (y en este caso solo) la palabra en la
región. Esto significa que cuando (recursive-count-words
region-end) está evaluada una segunda vez, como un resultado de la
llamada recursiva, el valor del punto será igual o mayor que el
valor de la región final. Así esta vez,
recursive-count-words devolverá cero. El cero será
añadido a uno, y la evaluación original de
recursive-count-words devolverá uno más cero, que es uno,
que es la cantidad correcta.



Claramente, si hay dos palabras en la región, la primera llamada a
recursive-count-words devuelve uno añadido al valor devuelto
llamando recursive-count-words en una región contiendo la
palabra que permanece --- que es, eso añade uno a uno, produciendo
dos, que es la cantidad correcta.



Similarmente, si hay tres palabras en la región, la primera llamada
recursive-count-words devuelve uno añadido al valor devuelto
llamado recursive-count-words en una región conteniendo las
dos palabras que permanecen --- y así y así.



Con documentación completa las dos funciones se parecen a esto:



La función recursiva:




 
(defun recursive-count-words (region-end)
  "Número de palabras entre punto y REGION-END."



;;; 1. do-again-test
  (if (and (< (point) region-end)
           (re-search-forward "\\w+\\W*" region-end t))



;;; 2. then-part: la llamada recursiva
      (1+ (recursive-count-words region-end))

;;; 3. else-part
    0))




El envoltorio:



 
;;; Versión Recursiva
(defun count-words-region (beginning end)
  "Imprime el número de palabras en la región.



Las palabras son definidas como al menos una palabra constituyente
seguida por al menos un caracter que es una palabra constituyente. La
tabla de sintaxis del buffer determina qué caracter hay.
  (interactive "r")
  (message "Contando palabras en la región ... ")
  (save-excursion
    (goto-char beginning)
    (let ((count (recursive-count-words end)))

      (cond ((zerop count)
             (message
              "La región no tiene palabras."))

            ((= 1 count)
             (message "La región tiene 1 palabra."))
            (t
             (message
              "La región tiene %d palabras." count))))))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




13.3 Ejercicio: Contando Puntuación



Usando un bucle while, escribe una función para contar el
número de marcas de puntuación en una región --- periodo, coma,
punto y coma, dos puntos, exclamación, marca y marca de
pregunta. Haz lo mismo usando recursión.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14. Contando Palabras en una defun





Nuestro siguiente proyecto es contar el número de palabras en una
definición de función. Claramente, esto puede ser hecho usando
alguna variante de count-word-region. Véase la sección  Contando Palabras: Repetición y Regexps. Si estamos ahora yendo a
contar las palabras en una definición, es suficiente fácil para
marcar la definición con el comando C-M-h (mark-defun),
y entonces llamar a count-word-region.



Sin embargo, soy más ambicioso: Yo quiero contar las palabras y
símbolos en cada definición en las fuentes de Emacs y
entonces imprime un grafo que muestre cuantas funciones hay de cada
tamaño: cuantas contienen de 40 a 49 palabras o
símbolos, cuantas contienen de 50 a 59 palabras o
símbols, y así. Yo he sido con frecuencia
curioso de cómo es una función típica, y esto se
contará.





Divide y Vencerás  



14.1 ¿Qué Contar?    ¿Qué contar?



14.2 ¿Qué Constituye un Palabra o Símbolo?     ¿Qué constituye una palabra o 
                               símbolo?



14.3 La Función count-words-in-defun       Muy como count-words.



14.4 Contar Varias defuns Con un Fichero           Contando varias funciones en un fichero.



14.5 Encontrar un Fichero       ¿Quieres buscar en un fichero?



14.6 lengths-list-file en Detalle          Una lista de los tamaños de muchas 
                               definiciones.



14.7 Contar Palabras en defuns en Diferentes Ficheros            Contando en definiciones en diferentes 
                               ficheros.



14.8 Recursivamente Cuenta Palabras en Diferentes Ficheros    Recursivamente contando en diferentes 
                                      ficheros.



14.9 Preparar los Datos para Mostrarlos en un Grafo         Preparar los datos para mostrarlos en un grafo.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Divide y Vencerás



Descrito en una frase, el histograma del proyecto es desanimar; pero
dividido dentro de numerosos pequeños pasos, cada uno de los que
podemos tomar en un momento, el proyecto llegar ser menos
atemorizante. Permítenos considerar qué pasos deben ser:





\texclamdownEsto es un proyecto! Pero si tomamos cada paso lentamente, eso
no
será difícil.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.1 ¿Qué Contar?




Cuando nosotros primero empezamos pensando acerca del contaje de
palabras en una definición de función, la primera pregunta es (o
podría ser) que está yendo a contar? Cuando se habla
de `palabras' con repecto a una definición de función Lisp,
estamos actualmente hablando, en larga parte, de
`símbolos'. Por ejemplo, la siguiente función
multiply-by-seven contiend los cinco símbolos
defun, multipy-by-seven, number, *, y
7. Además, en la cadena de documentación, contiene cuatro
palabras ‘Multiplicar’, ‘NUMBER’, ‘por’, y
‘siete’. El símbolo ‘número’ es repetido,
así la definición contiene un total de diez palabras y
símbolos.



 
(defun multiply-by-seven (number)
  "Multiply NUMBER by seven."
  (* 7 number))




Sin embargo, si se marca la definición multiply-by-seven con
C-M-h (mark-defun), y entonces llama a
count-words-region dentro, se encontrará que
count-words-region \texclamdownreclama la definicón tiene
once palabras, no diez! \texclamdownAlguna cosa está mal!



El problema es doble: count-words-region no cuenta el ‘*’
como una palabra, y eso cuenta el símbolo simple,
multiply-by-seven, conteniendo tres palabras. Las conexiones
son tratadas como si fueran espacios entre palabras en vez de
conectores entre palabras ‘multiply-by-seven’ es contado como si
fuese escrito ‘multiply-by-seven’.



La causa de esta confusión es la expresión regular busca con la
definición count-words-region que mueve el punto hacia
delante palabra por palabra. En la versión canónica de
count-words-region, el regexp es:



 
"\\w+\\W*"




Esta expresión regular es un patrón definiendo una o más
palabras constituyendo caracteres posiblemente seguidos por uno o
más caracteres que no son palabras constituyentes. Esto significa
que los `caracteres que consituyen palabras' nos traen la cuestión
de la sintaxis, que es el valor de una sección en sí.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.2 ¿Qué Constituye un Palabra o Símbolo?




Emacs trata diferentes caracteres perteneciendo a diferntes
categorías de sintaxis. Por ejemplo, la
expresión regular, ‘\\w+’, es un patrón especificando uno o
más caracteres de palabras constituyentes. Los caracteres de
palabras constituyentes son miembros de una categoría
sintaxis. Otras categorías de sintaxis incluyen de la
clase de caracteres de puntuación, tales como el espacio en blanco
el caracter tab. (Para más información, ver Sintaxis: (emacs)Sintaxis sección `La Tabla de Sintaxis' en El Manual GNU Emacs, y
(elisp)Tablas de Sintaxis sección `Tablas de Sintaxis' en El Manual de Referencia GNU Emacs Lisp.)



Las tablas de sintaxis especifican qué caracteres pertenecen a qué
categorías. Normalmente una conexión no está
especificado como un `caracter constituido por una palabra'. En vez de
eso, se especificó como estando en la `clase de caracteres que son
parte de los nombres de símbolo, pero no las palabras.'
Esto significa que la función count-words-region lo trata del
mismo modo que trata un espacio en blanco entre palabras, que es el
por qué count-words-region cuenta ‘multiply-by-seven’
como tres palabras.



Hay dos caminos para causar que Emacs cuente ‘multiply-by-seven’
como un símbolo: modifica la tabla de sintaxis o
modifica la expresión regular.



Se podría redefinir una conexión como un caracter que
constituye una palabra modificando la tabla de sintaxis que Emacs
guarda por cada modo. Esta acción serviría nuestro
propósito, excepto que una conexión es meramente el caracter más
común con símbols que no son típicamente
un caracter de palabra constituyente; hay otros, también.



Alternativamente, se puede redefinir la expresión regular usada en
la definición count-words así como incluir
símbolos. Este procedimiento tiene el mérito de la
claridad, pero la tarea es un pequeño truco.



La primera parte es suficientemente simple: el patrón debe asignarse
``al menos un carácter que es una palabra o símbolo
constituyente''. De este modo:



 
"\\(\\w\\|\\s_\\)+"




El ‘\\(’ es la primera parte del constructo que agrupa esto que
incluye el ‘\\w’ y el ‘\\s_’ como alternativas, separadas
por los ‘\\|’.  El ‘\\w’ asocia cualquier caracter de
palabra constituyente y el ‘\\s_’ asocia cualquier caracter que
es parte de un nombre de símbolo pero no una palabra de
caracteres constituyente. El ‘+’ siguiendo el grupo indica que la
palabra o símbolo constituyen caracteres que deben ser
asociado al menos por uno.



Sin embargo, la segunda parte de regexp es más difícil
para diseñar. Lo que queremos es seguir la primera parte con
``opcionalmente uno o más caracteres que no constituyen una palabra
o símbolo''. Primero, se pensaba que
podría definir esto con el siguiente:



 
"\\(\\W\\|\\S_\\)*"




Las mayúsculas ‘W’ y ‘S’ asocian caracteres que no
son constituyente de palabra o
símbolo. Desafortunadamente, esta expresión asocia
cualquier caracter que sea o no una palabra constituyente no un
símbolo constituyente. \texclamdownEsto asocia
cualquier caracter!



Entonces se notificó que cada palabra o símbolo en mi
región test fué seguida por espacio en blanco (espacio en blanco,
tabulador, o nueva línea). Así yo
intenté emplazar un patrón para asociar uno o más espacios en
blanco después del patrón para una o más palabras o
símbolos constituyentes. Esto falló,
también. Palabras y símbolos son con frecuenca
separados por espacios en blanco, pero en el código actual los
paréntesis pueden seguir símoblos y puntuación puede
seguir las palabras. Así finalmente, se diseño un
patrón en el que la palabra o símbolo constituyentes
son seguido opcionalmente por caracteres que no son espacios en blanco
y entonces seguidos opcionalmente por espacios en blanco.



Aquí está la expresión regular completa:



 
"\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.3 La Función count-words-in-defun




Se ha visto que hay varios caminos para escribir una función
count-word-region. Para escribir un
count-words-in-defun, se necesita meramente adapatar una de
estas versiones.



La versión que usa un bucle while es fácil de comprender,
así estoy yendo a adaptar esto. Porque
count-words-in-defun será parte de un programa más
complejo, eso no necesita ser interactivo y no necesita mostrar un
mensaje pero solo devuelve el contaje. Estas consideracionjes
simplifican la definición un poco.



Por otro lado, count-words-in-defun será usado con un buffer
que contiene definiciones de función. Consiguientemente, es
razonable preguntar que la función determina si se llamó cuando el
punto está con una definición de función, y eso es, para
devolver el contaje para esta definición. Esto añade complejidad a
la definición, pero nos guarda desde la necesidad de pasar
argumentos a la función.



Estas consideractiones se lidera para preparar la siguiente plantilla:



 
(defun count-words-in-defun ()
  "documentation…"
  (set up…
     (while loop…)
   return count)




Tan usual, nuestro trabajo es rellenar los slots.



Primero, la configuraci'on.



Estamos presuponiendo que esta función será llamada con un
búffer conteniendo definiciones de función. Apunta si será con
una definición de función o no. Para que
count-words-in-defun funcione, el punto debe moverse al
principio de la definición, un contador debe empezar a cero, y el
bucle contando debe parar cuando el punto logre el fin de la definición.



La función beginning-of-defun busca atrás para un
delimitador de apertura tal como ‘(’ al principio de una
línea, y mueve el punto a esta posición, o sino al
límite de la búsqueda. En práctica, esto significa
que beginning-of-defun mueve el punto al principio de un cierre
o definición de función precedente, o sino al principio del buffer.



El bucle while requiere un contador para guardar la traza de
las palabras o símbolo siendo contados. Una expresión
let puede ser usado para crear una variable local para este
propósito, y lo asocia a un velor inicial de cero.



La función end-of-defun funciona como
beginning-of-defun excepto que mueve el punto al fin de la
definición. end-of-defun puede ser usado como parte de una
expresión que determina la posición del fin de la definición.



La configuración para count-words-in-defun toma forma
rápidamente: primero movemos el punto al principio de la
definición, entonces se crea una variable local para manejar el
conteo, y finalmente, se graba la posición del fin de la
definición así el bucle while conocerá cuando
parar el bucle.



El código se parece a esto:



 
(beginning-of-defun)
(let ((count 0)
      (end (save-excursion (end-of-defun) (point))))




El código es simple. La única ligera complicación es
probablemente ir al end: eso está asociado a la posición
del fin de la definición por una expresión save-excursion
que devuelve el valor del punto después de end-of-defun
temporalmente se mueve al fin de la definición.



La segunda parte del count-words-in-defun, después de la
configuración, es el bucle while.



El bucle debe contener una expresión que salta en punto hacia
adelante palabra por palabra y símbolo por
símbolo, y otra expresión que cuenta los saltos. El
true-or-false-test para el bucle while chequería
verdadero tan largo como el punto debería saltar hacia
adelante, y falso cuando apunta al fin de la definición. Ya se ha
redefinido la expresión regular para esta (@pxref{Sintaxis}),
así el bucle es sencillo:



 
(while (and (< (point) end)
            (re-search-forward
             "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*" end t)
  (setq count (1+ count)))




La tercera parte de la definición devuelve el contaje de palabras y
símbolos. Esta parte es la última expresión con el
cuerpo de la expresión let, y puede ser, muy la variable
local count, que cuando evaluado devuelve el contaje.



Puesto junto, la definición count-words-in-defun se ve como esto:




 
(defun count-words-in-defun ()
  "Devuelve el número de palabras y símbolos en una defun."
  (beginning-of-defun)
  (let ((count 0)
        (end (save-excursion (end-of-defun) (point))))

    (while
        (and (< (point) end)
             (re-search-forward
              "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
              end t))
      (setq count (1+ count)))
    count))




Cómo se chequea esto? La función no es interactiva, pero es
fácil poner un envoltorio alrededor de la función para hacerlo
interactiva; se puede usar casi el mismo código como la versión
recursiva de count-words-region:



 
;;; Versión Interactiva.
(defun count-words-defun ()
  "Número de palabras y símbolos en una definición
  de función."
  (interactive)
  (message
   "Contando palabras y símbolos en la definición de función ... ")

  (let ((count (count-words-in-defun)))
    (cond
     ((zerop count)
      (message
       "La definición NO tiene palabras o símbolos."))

     ((= 1 count)
      (message
       "La definición tiene 1 palabra o símbolo."))
     (t
      (message
       "La definición tiene %d palabras o símbolos." count)))))




Permite reutilizar C-c = como un atajo conveniente:



 
(global-set-key "\C-c=" 'count-words-defun)




Ahora se puede intentar count-words-defun: instala ambas
funciones count-words-in-defun y count-words-defun, y
asigna el atajo, y entonces emplaza el cursor con la siguiente definición:



 
(defun multiply-by-seven (number)
  "Multiplicar NUMBER por siete."
  (* 7 number))
     ⇒ 10




\texclamdownÉxito! La definición tiene 10 palabras y
símbolos.



El siguiente problema es contar los números de palabras y
símbolos en varias definiciones con un fichero simple.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.4 Contar Varias defuns Con un Fichero



Un fichero tal como ‘simple.el’ puede tener un centenar o más
definiciones de función con eso. Nuestro término objetivo es
recoger estadísticas en muchos ficheros, pero como un
primer paso, nuestro objetivo inmediato es recoger
estadísticas en un fichero.



La información será una serie de números, cada número siendo
el tamaño de una definición de función. Se puede almacenar los
número en una lista.



Saber que querremos incorporar la información considerando un
fichero con información acerca de muchos otros ficheros; esto
significa que la función para contar el tamaño de contaje con un
fichero solo necesita devolver la lista de tamaños. Eso necesita no
mostraría mensajes.



Los comando de contar palabras contienen una expresión para saltar
el punto hacia delante palabra por palabra y otra expresión para
contar los saltos. La función devuelve los tamaños de definiciones
que pueden ser diseñadas para trabajar del mismo modo, con una
expresión para saltar el punto hacia la definición por
definición y otra expresión para construir el tamaño de la lista.



Esta frase del problema hace elemental escribir la definición de
función. Claramente, empezaremos el conteo la principio del fichero,
así el primer comando será (goto-char
(point-min)). Lo siguiente, empezaremos el bucle while; y este
true-or-false del bucle puede ser una búsqueda de expresión
regular para la siguiente definición de función ---
así tan largo como la búsqueda tiene éxito, el punto
se mueve hacia adelante y entonces el cuerpo del bucle es evaluado. El
cuerpo necesita una expresión que construye la lista de
tamaños. cons, la lista de construcción del comando, puede
ser usado para crear la lista. Esto es casi todo lo que hay.



Aquí está este fragmento de código se mira como:



 
(goto-char (point-min))
(while (re-search-forward "^(defun" nil t)
  (setq lengths-list
        (cons (count-words-in-defun) lengths-list)))




Dejamos fuera el mecanismo para encontrar el fichero que contiene las
definiciones de función.



En ejemplos previos, nosotros habíamos usado esto, el
fichero Info, o cambiamos atrás y delante a algún otro búffer,
tal como el búffer ‘*scratch*’.



Encontrando un fichero es un nuevo proceso que no tenemos
todavía discutido.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.5 Encontrar un Fichero




Para encontrar un fichero en Emacs, se usa el comando @kdb{C-x C-f}
(find-file). Este comando es casi, pero no bastante correcto
para el problema de tamaños.



Permite mirar el fuente para find-file:



 
(defun find-file (filename)
  "Edita el fichero FILENAME.
Cambia a un búffer visitando el fichero FILENAME,
creando uno si no existe ya."
  (interactive "FFind file: ")
  (switch-to-buffer (find-file-noselect filename)))




(La versión más reciente de la definición de función
find-file permite especial comodines para visitar múltiples
ficheros; que hacen la definiciń más compleja y no lo discutirá
aquí, ya que no es relevante. Se puede ver sus fuentes
usando M-. (find-tag) o C-h f
(describe-function).)




La definición que se está mostrando posee una documentación
corta, pero completa y una especificación interactiva que muestra un
nombre de fichero cuando se usa el comando interactivamente. El cuerpo
de la definición contiene dos funciones, find-file-noselect y
switch-to-buffer.



De acuerdo a su documentación como muestra por C-h f (el
comando describe-function), la función
find-file-noselect lee el fichero nombredo dentro de un
búffer y devuelve el búffer. (Su versión más reciente incluye
un argumento comodín, también, tan bien como otro para
leer un fichero literalmente y otro suprime mensajes de aviso. Estos
argumentos opcionales son irrelevantes.) 



Sin embargo, la función find-file-noselect no selecciona el
búffer en el que se pone el fichero. Emacs no cambia su atención
(o la tuya si estás usando find-file-noselect) al búffer
seleccionado. Esto es lo que switch-to-buffer hace: eso cambia
el buffer al que la atención de Emacs es dirigida; y eso cambia el
buffer mostrado en la ventana al nuevo buffer. Hemos discutido el
buffer cambiando a otro lugar. (Véase la sección  Cambiando Buffers.)



En este proyecto de histograma, no se neceista mostrar cada fichero en
la pantalla como el programa determina el tamaño de cada
definición con eso. En vez de emplear switch-to-buffer, se
puede trabajar con set-buffer, que redirige la atención del
programa de ordenador para un buffer diferente pero no lo muestra en
pantalla. Así en vez llamar a find-file para
hacer el trabajo, debe escribir nuestra expresión.



La tarea es fácil: usar find-file-noselect y set-buffer.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.6 lengths-list-file en Detalle



El núclero de la función legths-list-file es un bucle
while conteniendo una función para mover el punto hacia
delante `función a función' y una función para contar el
número de palabras y símbolos en cada función. Este
núcleo debe ser rodeado por funciones que hacen otras tareas varias,
incluyendo encontrar el fichero, y asegurando que el punto empieza al
principio del fichero. La definición de la función se parece a esto:




 
(defun lengths-list-file (filename)
  "Devuelve la lista de tamaños de definiciones con FILE.
La lista devuelta es una lista de números.
Cada número es el número de palabras o
símbolos en una definición."

  (message "Trabajando en `%s' ... " filename)
  (save-excursion
    (let ((buffer (find-file-noselect filename))
          (lengths-list))
      (set-buffer buffer)
      (setq buffer-read-only t)
      (widen)
      (goto-char (point-min))
      (while (re-search-forward "^(defun" nil t)
        (setq lengths-list
              (cons (count-words-in-defun) lengths-list)))
      (kill-buffer buffer)
      lengths-list)))




La función pasa un argumento, el nombre del fichero en el que
trabajará. Eso tiene cuatro líneas de documentación,
pero sin especificación interactiva. Desde que la gente se preocupa
que un ordenador está roto si ellos no ven cualquier cosa yendo, la
primera línea del cuerpo es un mensaje.



La siguiente línea contiene un save-excursion que
devuelve a Emacs la atención al actual búffer cuando la función
se completa. Esto es útil en caso de embeber esta función en otra
función que presume el punto es restaurada al búffer original.



En la varlist de la expresión let, Emacs encuentra el fichero
y ajusta la variable local buffer al búffer conteniendo el
fichero. Al mismo tiempo, Emacs crea legths-list como una
variable local.



Lo siguiente, Emacs cambia su atención al búffer.



En la siguiente línea, Emacs crea el búffer de solo
lectura. Idealmente, esta línea no es necesaria. Ninguna
de las funciones para contar palabras y símbolos en una
definición de función cambiaría el búfer. Debajo,
el búffer no está yendo para ser guardado, incluso si eso fuese
cambiado. Esta línea es enteramente la consecuencia de
grata, quizás excesiva precaución. La razón para la precaución
es que esta función y esta se llama a trabajar en las fuentes para
Emacs y eso es inconveniente si ellos están inadvertidamente
modificadas. Eso va sin decir que no se realizó una necesidad para
esta línea hasta que un experimento fué cambiado hacia
un lado y empezó a modificar mis ficheros de fuentes Emacs …



Lo siguiente llama a alargar el búffer si eso está encogido. Esta
función es normalmente innecesaria --- Emacs crea un buffer fresco
si ninguno ya existe; pero si un búffer visitando el fichero que ya
existe que Emacs devuelve uno. En este caso, el buffer puede ser
encogido y debe ser amplio. Si se quiere ser completamente `amigo del
usuario', se pondría en orden guardar la restricción y
la localización del punto, pero no.



La expresión (goto-char (point-min)) mueve el punto al
principio del búffer.



Entonces llega un bucle while en el que el `trabajo' de la
función es traido. En el bucle, Emacs determina el tamaño de cada
definición y construye una lista de tamaños conteniendo la
información.



Emacs corta el búffer después trabajando a través de eso. Esto
es guardar espacio dentro de Emacs. Mi versión de GNU Emacs 19
contenía 300 ficheros fuente de interés; GNU Emacs 22
contiene a través de un millar de ficheros fuente. Otra función
aplicará lengths-list-file a cada uno de los ficheros.



Finalmente, la última expresión con la expresión let es
la variable lengths-list; su valor es devuelto como el valor de
la función completa.



Se puede probar esta función instalándolo en el modo
usual. Entonces posiciona tu cursor después de la siguiente
expresión y escribe C-x C-e (eval-last-sexp).



 
(lengths-list-file
 "/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/debug.el")




(Se puede necesitar cambiar la ruta del fichero; el único
aquí es para GNU Emacs versión 22.1.1. Para cambiar la
expresión, cópialo para buffer ‘*scratch*’ y edítalo.



(También, para ver el tamaño completo de la lista, en vez de una
versión truncada se puede tener que evaluar lo siguiente:



 
(custom-set-variables '(eval-expression-print-length nil))




(Véase la sección  Especificando Variables usando defcustom. Entonces evalúa la expresión
lengths-list-file.)



La lista de tamaños para ‘debug.el’ toma menos de un segundo
para producirse como esto en GNU Emacs 22:



 
(83 113 105 144 289 22 30 97 48 89 25 52 52 88 28 29 77 49 43 290 232 587)




(Usando mi vieja máquina, la versión 19 tamaños lista para
‘debug.el’ se ven siete segundos para producir y mirar como esto:



 
(75 41 80 62 20 45 44 68 45 12 34 235)




(La versión nueva de ‘debug.el’ contiene más defuns que la
temprana; y mi nueva máquina es muy rápido que el viejo.



Nótese que el tamaño de la última definición en el fichero es
el primero en la lista.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.7 Contar Palabras en defuns en Diferentes Ficheros



En la sección previa, se creaba una función que devuelve una lista
de los tamaños de cada definición en un fichero. Ahora, se quiere
definir una función para devolver una lista maestra de los tamaños
de las definiciones en una lista de ficheros.



Trabajando en cada de una lista de ficheros es un acto repetitivo,
así se puede usar un bucle while o recursión.





Determina las longitudes de defuns    Devolver una lista de tamaños de funciones.



14.7.1 La Función append                     Adjuntar una lista a otra.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Determina las longitudes de defuns



El diseño usando un bucle while es rutina. El argumento
pasaba la función es una lista de ficheros. Como se vió pronto
(véase la sección Un bucle while y una Lista), se puede escribir un bucle while
así que el cuerpo del bucle es evaluado si tal lista
contiene elementos, pero sale del bucle si la lista está
vacía. Para que este diseño funcione, el cuerpo del
bucle debe contener una expresión que ordene la lista cada vez que
el cuerpo es evaluado, así que finalmente la lista
está vacía. La técnica normal es asignar el valor de
la lista para el valor del CDR de la lista cada vez que el cuerpo
es evaluado.



La plantilla se ve así:



 
(while test-whether-list-is-empty
  body…
  set-list-to-cdr-of-list)




También, recuérdanos que un bucle while devuelve nil
(el resultado de evaluar el true-or-false-test), no el resultado de
cualquier evaluación con su cuerpo. (Las evaluaciones con el cuerpo
del bucle son hechas para sus efectos laterales.) Sin embargo, la
expresión que asigna la lista de tamaños es parte del cuerpo --- y
que es el valor que queremos devuelto por la función como un
todo. Para hacer esto cerramos el bucle while con una
expresión let, y pone en orden que el último elemento de la
expresión let contiene el valor de lista de
tamaños. (@xref{Incrementando el Ejemplo, , El Ejemplo del Bucle con
un Contandor de Incremento}.)




Estas consideraciones lideran directamente a la función en
sí:



 
;;; Usar bucle while.
(defun lengths-list-many-files (list-of-files)
  "Devuelve la lista de tamaños de funciones en LIST-OF-FILES."

  (let (lengths-list)

;;; true-or-false-test
    (while list-of-files
      (setq lengths-list
            (append
             lengths-list

;;; Genera una lista de tamaños.
             (lengths-list-file
              (expand-file-name (car list-of-files)))))



;;; Crea una lista ordenada de ficheros.
      (setq list-of-files (cdr list-of-files)))

;;; Devuelve la lista final de valores de tamaños.
    lengths-list))




expand-file-name es una función construida que convierte un
nombre de fichero al absoluto, largo, forma de nombre de ruta. La
función emplea el nombre del directorio en el que la función se llama.



De este modo, si expand-file-name es llamado en debug.el
cuando Emacs está visitando el directorio
‘/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/’



 
debug.el




llegar a ser



 
/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/debug.el




El único otro nuevo elemento de esta definición de función es
la todavía no estudiada función append, que
merece una corta sección en sí.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.7.1 La Función append



La función append adjunta una lista a otra. De este modo,,



 
(append '(1 2 3 4) '(5 6 7 8))




produce la lista



 
(1 2 3 4 5 6 7 8)




Esto es exactamente como queremos adjuntar dos listas de tamaños
producidas por lengths-list-file a cualquier otro. Los
resultados contrasta con cons,



 
(cons '(1 2 3 4) '(5 6 7 8))




que construye una nueva lista en el que el primer argumento para
cons llega a ser el primer elemento de la nueva lista:



 
((1 2 3 4) 5 6 7 8)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.8 Recursivamente Cuenta Palabras en Diferentes Ficheros



Bajo un bucle while, se puede trabajar cada lista de ficheros
con recursión. Una versión recursiva de
lengths-list-many-files es corta y simple.



La función recursiva tiene las partes normales: el `do-again-test',
la `next-step-expression', y la llamada recursiva. El `do-again-test'
determina si la función llamarí en sí de
nuevo, que hará si la list-of-files contiene los elementos
que permanecen; la `next-step-expressioon' resetea el
list-of-files al CDR en sí,
así finalemnte la lista será vacía; y la
llamada recursiva llama en sí a la lista
ordenada. \textexclamdownLa función completa está ordenada por
esta descripción!




 
(defun recursive-lengths-list-many-files (list-of-files)
  "Devuelve la lista de tamaños de cada defun en LIST-OF-FILES."
  (if list-of-files                     ; do-again-test
      (append
       (lengths-list-file
        (expand-file-name (car list-of-files)))
       (recursive-lengths-list-many-files
        (cdr list-of-files)))))




En una frase, la función devuelve de tamaños de la lista para la
el primero de la list-of-files al resultado de llamarse
así mismo al resto de list-of-files.



Aquí hay un test
recursive-lengths-list-many-files, a lo largo de los resultados
de ejecutar lengths-list-file en cada uno de los ficheros
individualmente.



Instala recursive-lengths-list-many-files y
lengths-list-file, si es necesario, y entonces evalúa las
siguientes expresiones. Se puede necesitar cambiar las rutas de
ficheros; estos aquí trabajan cuando este fichero Infor
y las fuentes de Emacs están localizadas en sus lugares
personaLES. Para cambiar las expresiones, cópiales al buffer
‘*scratch*’, edítalos y entonces evalúalos.



Los resultados son mostrados después del ‘⇒’. (Estos
resultados son para ficheros de Emacs versión 22.1.1; ficheros desde
otras versiones de Emacs puede producir diferentes resultados.)



 
(cd "/usr/local/share/emacs/22.1.1/")

(lengths-list-file "./lisp/macros.el")
     ⇒ (283 263 480 90)



(lengths-list-file "./lisp/mail/mailalias.el")
     ⇒ (38 32 29 95 178 180 321 218 324)



(lengths-list-file "./lisp/makesum.el")
     ⇒ (85 181)



  (recursive-lengths-list-many-files
   '("./lisp/macros.el"
     "./lisp/mail/mailalias.el"
     "./lisp/makesum.el"))
       ⇒ (283 263 480 90 38 32 29 95 178 180 321 218 324 85 181)




La función recursive-lengths-list-many-files produce la
salido que queremos.



El siguiente paso es preparar el dato en la lista para mostrar en un grafo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.9 Preparar los Datos para Mostrarlos en un Grafo



La función recursive-lengths-list-many-files devuelve una
lista de números. Cada número graba el tamaño de una
definición de función. Lo que necesitamos para hacer ahora es
transformar estos datos dentro de una lista de números ajustado para
generar un grafo. La nueva lista contará cuantas definiciones de
funciones conteniendo menos de 10 palabras y símbolos,
cuanto contiene entre 10 y 19 palabras y símbolos,
cuánto contiene entre 20 y 29 palabras y símbolos, y
así.



En breve, se necesita ir a través el tamaño de la lista producida
por la función recursive-lengths-list-many-files y contar el
número de defuns con cada rango de tamaños, y produce una lista de
esto números.





El Dato para Mostrar en Detalle  



14.9.1 Ordenando Listas                  Ordenando listas.



14.9.2 Creando una Lista de Ficheros            Creando una lista de ficheros.



14.9.3 Contando definiciones de función    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




El Dato para Mostrar en Detalle



Basado en lo que hemos hecho antes, se prevee que no
sería difícil escribir una función que
`CDRs' bajo la lista de tamaños, parece en cada elemento,
determina que rango de tamaños está dentro, e incrementa un
contador para este rango.



Sin embargo, antes de empezar a escribir tal función, nosotros
consideraríamos las ventajas de ordenar los tamaños de
la lista primero, así los números son ordenados desde
el más pequeño al más largo. Primero, ordenando hará fácil
contar los números en cada rango, desde dos números adyacentes
será el mismo rango del tamaño en rangos adyacentes. Segundo,
inspeccionando una lista ordenada, se puede descubrir el número
mayor y menor, y esto significa determinar el rango de tamaño mayor
y menor que necesitará.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.9.1 Ordenando Listas




Emacs contiene una función para listas ordenadas, llamadas (como se
podría adivinar) sort. La función sort
toma dos argumentos, la lista es ordenada, y un predicado que
determina si la primera de dos elementos de lista es ``menor'' que la
segunda.



Como se vió antes (@pxref{Mal Tipo de Argumento, , Usando el Tipo
Incorrecto de Objeto como un Argumento}), un predicado es una
función que determina si alguna propiedad es verdadera o falsa. La
función sort reordenará una lista de acuerdo a lo que la
propiedad del predicado usa; esto significa que sort puede ser
usado para ordenar listas no numéricas por un criterio no numérico
--- eso puede, por ejemplo, alfabetizar una lista.



La función < es usado cuando ordenas una lista
numérica. Por ejemplo,



 
(sort '(4 8 21 17 33 7 21 7) '<)




produce esto:



 
(4 7 7 8 17 21 21 33)




(Note que en este ejemplo, ambos argumentos son citados
así que los símbolos no son evaluados
antes de ser pasados para sort como argumentos.)



Ordenando la lista devuelta por la función
recursive-lengths-list-many-files es honesta; eso usa la
funciń <:




 
(sort
 (recursive-lengths-list-many-files
  '("./lisp/macros.el"
    "./lisp/mailalias.el"
    "./lisp/makesum.el"))
 '<)




que produce:



 
(29 32 38 85 90 95 178 180 181 218 263 283 321 324 480)




(Note que en este ejemplo, el primer argumento para sort no
está citado, desde que la expresión debe ser evaluado
así como producir la lista que es pasada para sort.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.9.2 Creando una Lista de Ficheros



La función recursive-lengths-list-many-files requiere una
lista de fichero como su argumento. Para nuestros ejemplos de test, se
construyeron tal como una lista a mano; pero el directorio fuente de
Emacs Lisp es demasiado largo para nosotros para hacer esto. En vez,
se escribirá una función para hacer el trabajo para nosotros. En
esta función, usaremos ambos un bucle while y una llamada
recursiva.




Nosotros no tuvimos que escribir una función como esta para viejas
versiones de GNU Emacs, desde que todos los ficheros ‘.el’ en un
directorio. En vez deeso, seremos capaces de usar la función
directory-files, que lista los nombres de fichero que asocian
un patrón específicos con un directorio simple.



Sin embargo, las versiones reciente Emacs emplazan fichero de Emacs
Lisp en subdirectorios del directorio de alto nivel ‘lisp’. Esto
facilita la navegación. Por ejemplo, todo los ficheros de correo
relacionados están en subdirectorio llamado ‘mail’. Pero al
mismo tiempo, este facilidad nos fuerza a crear un fichero listando la
función que desciende dentro de los subdirectorios.




Se puede crear esta función, llamada
files-en-below-directory, usando funciones familiares tales
como car, nthcdr, y substring en conjunción con
una función existente llamada
directory-files-and-attributes. Esta última función no solo
listas de ficheros en un directorio, incluyendo los nombres de
subdirectorios, pero también sus atributos.



Para empezar nuestro objetivo: crear una función que nos permita
alimentas ficheros a recursive-lengths-list-many-files como una
lista que se parece a esto (pero con más elementos):



 
("./lisp/macros.el"
 "./lisp/mail/rmail.el"
 "./lisp/makesum.el")




La función directory-files-and-attributes devuelve una lista
de listas. Cada una de las listas con la lista principal consiste de
13 elementos. El primer elemento es una cadena que contiene el nombre
del fichero -- que, en GNU/Linux, puede ser un `fichero directorio',
que dice, un fichero con los atributos especiales de un directorio. El
segundo elemento de la lista es t para un directorio, una
cadena para el enlace simbólico (la cadena es el nombre enlazado), o
nil.



Por ejemplo, el primer fichero ‘.el’ en el directorio es
‘abbrev.el’. Su nombre es
‘/usr/local/share/emacs/22.1.1/lisp/abbrev.el’ y no es un
directorio o un enlace simbólico.



Esto es cómo directory-files-and-attributes lista este
fichero y sus atributos:



 
("abbrev.el"
nil
1
1000
100

(17733 259)
(17491 28834)
(17596 62124)
13157
"-rw-rw-r--"

nil
2971624
773)




Por otro lado, ‘mail/’ es un directorio con el directorio
‘lisp/’. El principio de su listado se parece a esto:



 
("mail"
t
…
)




(Para aprender acerca de los diferente atributos, mira en la
documentacióon de file-attributes. Tener en mente que la
función file-attributes no lista el nombre del fichero,
así su primer elemento es
directory-files-and-attributes es el segundo elemento.)



Se querrán nuestras nuevas funciones,
files-in-below-directory, para listar los fichero ‘.el’ en
el directorio eso es contado para chequear, y en los directorios bajo
este directorio.



Esto nos da una sugestión de como construir
files-in-below-directory: con un directorio, la función
añadir los nombres de ficheros ‘.el’ a una lista; y si, con un
directorio, la función viene con un subdirectorio,
iría dentro de este subdirectorio y repite sus acciones.



Sin embargo, nosotros notaríamos que cada directorio
contiene un nombre que se refiere a sí mismo, llamado
‘.’, (``dot'') y un nombre que se refiere a su directorio padre,
llamado ‘..’ (``doble punto''). (En ‘/’, el directorio
raíz, ‘..’ se refiere así mismo,
desde que ‘/’ no tiene padre.) Claramente, no que se quiere
nuestra función files-in-below-directory para introducir
estos directorio, desde que ellos siempre nos lideran, directamente o
indirectamente, al directorio actual.



Consecuentemente, nuestra función files-in-below-directory
debe hacer varias tareas:





Permita escribir una definición de función para hacer estas
tareas. Se usará un bucle while para mover de un nombre de
fichero a otro con un directorio chequeando lo que necesita ser hecho;
y usaremos una llamada recursiva para repetir las acciones en cada
subdirectorio. El patrón recursivo es `acumular' (véase la sección Patrón Recursivo: accumulate) usando append como el
combinado.





Aquí está la función:



 
(defun files-in-below-directory (directory)
  "Lista los fichero .el en DIRECTORIO y en sus subdirectorios."
  ;; Aunque la función será usada no interactivamente,
  ;; será fácil chequear si lo hacemos interactivo.
  ;; El directorio tendrá un nombre tal como
  ;;  "/usr/local/share/emacs/22.1.1/lisp/"
  (interactive "DNombre del Directorio: ")

  (let (el-files-list
        (current-directory-list
         (directory-files-and-attributes directory t)))
    ;; mientras estamos en el directorio actual
    (while current-directory-list

      (cond
       ;; chequee para ver si el nombre del fichero finaliza en `.el'
       ;; y si es así, añade su nombre a una lista.
       ((equal ".el" (substring (car (car current-directory-list)) -3))
        (setq el-files-list
              (cons (car (car current-directory-list)) el-files-list)))

       ;; chequee si el nombre del fichero es un directorio
       ((eq t (car (cdr (car current-directory-list))))
        ;; decide si escapar o recurrir
        (if
            (equal "."
                   (substring (car (car current-directory-list)) -1))
            ;; entonces no hagas nada desde que el nombre del fichero es
            ;; actual directorio o padre, "." o ".."
            ()

          ;; else desciende dentro del directorio y repite el proceso
          (setq el-files-list
                (append
                 (files-in-below-directory
                  (car (car current-directory-list)))
                 el-files-list)))))
      ;; mueve al siguiente fichero en la lista; esto también 
      ;; ordena la lista así mientras el bucle
      ;; eventualmente llega a un fin
      (setq current-directory-list (cdr current-directory-list)))
    ;; devuelve los ficheros
    el-files-list))





Las función files-in-below-directory directory-files
toma un argumento, el nombre de un directorio.



De este modo, en mi sistema,




 
(length
 (files-in-below-directory "/usr/local/share/emacs/22.1.1/lisp/"))




cuéntame que dentro y debajo de mi directorio de fuentes Lisp hay
1031 ficheros ‘.el’



files-in-below-directory devuelve una lista en orden
alfabético inverso. Una expresión para ordenar la lista en orden
que parece como este:



 
(sort
 (files-in-below-directory "/usr/local/share/emacs/22.1.1/lisp/")
 'string-lessp)










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




14.9.3 Contando definiciones de función



Nuestro objetivo inmediato es generar una lista que cuenta, cuantas
definiciones de funciones contienen menos de 10 palabras y
símbolos, cuantas contienen entre 10 y 19 palabras y
símbolos, cuantos contienen entre 20 y 29 palabras y
símbolos, y así.



Con una lista ordenada de números, esto es fácil: cuentas cuantos
elementos de la lista son más pequeños que 10, entonces, después
de mover al pasado los números solo contados, cuentas cuantos son
más pequeños de 20, entonces, después de mover pasado los
números solo contados, cuenta cuantos son más pequeños de 30, y
así. Cada uno de los números, 10, 20, 30, 40, y el
como, es uno más largo que el tope de este rango. Se puede llamar a
la lista de tales números la lista top-of-ranges.



Si se desea, se podría generar esta lista
automáticamente, pero es más simple escribir una lista
manualmente. Aquí está:




 
(defvar top-of-ranges
 '(10  20  30  40  50
   60  70  80  90 100
  110 120 130 140 150
  160 170 180 190 200
  210 220 230 240 250
  260 270 280 290 300)
 "Listar especificando rangos para `defuns-per-range'.")




Para cambiar los rangos, se edita esta lista.



Lo siguiente, que se necesita es escribir la función que crea la
lista del número de definiciones con cada rango. Claramente, esta
función debe tomar el sorted-lengths y las listas
top-of-ranges listas como argumentos.



La función defuns-per-range debe hacer dos cosas una y otra
vez: eso debe contar el número de definiciones con un rango
específico por el actual valor top-of-range; y eso debe
dividir al siguiente gran valor en la lista top-of-ranges
después de contar el número de definiciones en el rango
actual. Desde que cada una de estas acciones es repetitiva, se puede
usar los bucles while para el trabajo. Un bucle cuenta el
número de definiciones en el rango definido por el valor actual
top-of-range, y el otro bucle selecciona cada uno de los valores
top-of-range en turno.



Varias entradas de la lista sorted-lengths son contadas para
cada rango; esto significa que el bucle para la lista
sorted-lengths será dentro del bucle para la lista
top-of-ranges, como un pequeño adorno dentro de un gran adorno.



El bucle interno cuenta el número de definiciones con el rango. Eso
es un simple contaje del tipo que nosotros hemos visto
antes. (Véase la sección  Un bucle con un contador de incremento.) El test true-or-false del bucle chequea si el valor
desde la lista sorted-lengths es más pequeña que el actual
valor de lo alto del rango. Si eso es, la función incrementa el
contador y chequea el siguiente valor desde la lista sorted-lengths.



El bucle interno se parece a esto:



 
(while length-element-smaller-than-top-of-range
  (setq number-within-range (1+ number-within-range))
  (setq sorted-lengths (cdr sorted-lengths)))




El bucle de fuera debe empezar con el valor más bajo de la lista
top-of-ranges, y entonces asignares a cada uno de los valores
superiores exitosos a su vez. Esto puede ser hecho con un bucle como este:



 
(while top-of-ranges
  body-of-loop…
  (setq top-of-ranges (cdr top-of-ranges)))




Pon junto, los dos bucles como este:



 
(while top-of-ranges

  ;; Contar el número de elementos con el actual rango.
  (while length-element-smaller-than-top-of-range
    (setq number-within-range (1+ number-within-range))
    (setq sorted-lengths (cdr sorted-lengths)))

  ;; Mover al siguiente rango.
  (setq top-of-ranges (cdr top-of-ranges)))




Además, en cada circuito del bucle exterior, Emacs
grabaría el número de definiciones con este rango (el
valor de number-within-range) en una lista. Se puede usar
cons para este propósito. (Véase la sección  cons.)



La función cons trabaja bien, excepto que la lista que se
construye contendrá el número de definiciones para el alto rango y
su principio el número de definiciones para el más bajo rango a su
fin. Esto es porque cons adjunta nuevos elementos de la lista
al principio de la lista, y desde los dos bucles están trabajando su
camino a través de la lista de tamaños desde lo bajo finaliza
primero, el defuns-per-range-list finalizará el primer
número más largo. Pero nosotros querremos imprimir nuestro grafo
con pequeños valores primer y el más largo después. La
solución es invertir el orden del
defuns-per-range-list. Nosotros podemos hacer esto usando la
función nreverse, que invierte el orden de una lista.




Por ejemplo,



 
(nreverse '(1 2 3 4))




produce:



 
(4 3 2 1)




Note que la función nreverse es ``destructiva'' --- que es,
cambiar la lista para la que es aplicada; esto contrasta con las
fuciones car y cdr, que no son destructivas. En este
caso, no se quier el original defuns-per-range-list,
así no hay materia que sea destruida. (La función
reverse provee un copia inversa de una lista, dejando la lista
original como es.)




Pon todo junto, el defuns-per-range se parece a esto:



 
(defun defuns-per-range (sorted-lengths top-of-ranges)
  "funciones de SORTED-LENGTHS en cada rango TOP-OF-RANGES."
  (let ((top-of-range (car top-of-ranges))
        (number-within-range 0)
        defuns-per-range-list)



    ;; Bucle Exterior.
    (while top-of-ranges



      ;; Bucle Interno.
      (while (and
              ;; Necesita el número para el test numérico.
              (car sorted-lengths)
              (< (car sorted-lengths) top-of-range))



        ;; Contar número de definiciones con el rango actual.
        (setq number-within-range (1+ number-within-range))
        (setq sorted-lengths (cdr sorted-lengths)))

      ;; Sal del bucle interno pero permanece con el bucle externo.



      (setq defuns-per-range-list
            (cons number-within-range defuns-per-range-list))
      (setq number-within-range 0)      ; Resetear el contaje a cero.



      ;; Mover al siguiente rango.
      (setq top-of-ranges (cdr top-of-ranges))
      ;; Especifica el siguiente mejor rango de valores.
      (setq top-of-range (car top-of-ranges)))



    ;; Salir del bucle externo y contar el número de defuns más
    ;; largas que
    ;;   el valor más largo del valor top-of-range.
    (setq defuns-per-range-list
          (cons
           (length sorted-lengths)
           defuns-per-range-list))



    ;; Devuelve una lista del número de definiciones con cada rango,
    ;;  del más pequeño al más largo.
    (nreverse defuns-per-range-list)))




La función es simple excepto para una pequeña funcionalidad. El
test true-or-false para el bucle interno se parece a esto:



 
(and (car sorted-lengths)
     (< (car sorted-lengths) top-of-range))




en vez de algo como esto:



 
(< (car sorted-lengths) top-of-range)




El propśito del test es determinar si el primer ítem
en la lista sorted-lengths es menor que el valor de lo mejor
del rango.



La versión simple del test trabaja bien a menos que la lista
sorted-lengths tiene un valor nil. En este caso, la
expresión (car sorted-lengths) devuelve nil. La
función < no se puede compara un número a nil, que
es una lista vacía, así Emacs señala un
error y para la función desde el intento de continuar la ejecución.



La lista sorted-lengths siempre llega a ser nil cuando
el contador logra el fin de la lista. Esto significa que cualquier
intento de usar la función defuns-per-range con la versión
simple del test fallará.



Se resuelve el problema usando (car sorted-lengths) en
conjunción con la expresión and. La expresión (car
sorted-lengths) devuelve un valor no nil tan largo como la
lista que tiene al menos un número con eso, pero devuelve nil
si la lista está vacía. La expresión and
primero evalúa el (car sorted-lengths), y si eso es
nil, devuelve falso sin evaluar la expresión <
 y devuelve este valor como el valor de la expresión and.



Este camino, evita un error.



Aquí hay un pequeño test de la función
defuns-per-range. Primero, evalúa la expresión que ajusta
(una resumida) lista top-of-ranges a la lista de valores,
entonces evalúa la expresión para ajustar la lista
sorted-lengths, y entonces evalúa la función
defuns-per-range.



 
;; (La lista ordenada que usará después.)
(setq top-of-ranges
 '(110 120 130 140 150
   160 170 180 190 200))

(setq sorted-lengths
      '(85 86 110 116 122 129 154 176 179 200 265 300 300))

(defuns-per-range sorted-lengths top-of-ranges)




La lista devuelta se parece a esto:



 
(2 2 2 0 0 1 0 2 0 0 4)




Dentro, hay dos elementos de la lista sorted-legths menores de
110, dos elementos entre 110 y 119, dos elementos entre 120 y 129 y
así. Hay cuatro elementos con un valor de 200 o superior.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




15. Leyendo un Grafo







Nuestro objetivo es construir un grafo mostrando los números de
definiciones de función de varios tamaños en las fuentes de Emacs lisp.



Como una materia práctica, si estuvieses creando un grafo,
probablemente usarías un programa tal como
gnuplot para hacer el trabajo. (gnuplot está bien
integrado dentro de GNU Emacs.) En este caso, sin embargo, creamos uno
desde cero, y en el proceso reaguantaremos nosotros mismos con algo de
lo que aprendemos antes y aprender más.



En este capítulo, primero escribiremos un grafo simple
imprimiendo función. Esta primera definición será un
prototipo, una función escrita rápidamente que nos permite
reconocer este territorio creando un grafo. Nosotros descubriremos
dragones, o encontramos que son mitos. Después de olisquear el
terreno, nos sentiremos más confidentes y mejoraremos la función
para etiquetar las coordenadas automáticamente.





Imprimiendo las Columnas de un Grafo  



15.1 La Función graph-body-print           Cómo imprimir el cuerpo de un grafo.



15.2 La Función recursive-graph-body-print  



15.3 Necesidad para Ejes Impresos  



15.4 Ejercicio    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Imprimiendo las Columnas de un Grafo



Desde que Emacs está diseñado para ser flexible y trabajar con
todo tipo de terminales, incluyendo son terminales de caracteres, el
grafo necesitará ser hecho desde símbolos de
`escritura'. Un asterisco hará; como nosotros mejoramos la función
de impresión del grafo, se puede crear la elección del
símbolo una opción de usuario.



Se puede llamar a esta función graph-body-print; tomaremos un
numbers-list como su único argumento. En esta fase, no se
etiquetará el grafo, pero solo imprime su cuerpo.



La función graph-body-print inserta un columna vertical de
asteriscos para cada elemento en la lista numbers-list. La
altura de cada línea está determinada por el valor de
este elemento de la numbers-list.



Insertando columnas es un acto repetitivo; que significa que esta
función por ser escrito si con un bucle while o recursivamente.



Nuestro primer reto es descubrir como imprimir una columna de
asteriscos. Normalmente, en Emacs, se imprimen caracteres dentro de
una pantalla horizontalmente, línea a
línea, escribiendo. Se tienen dos rutas que se pueden
seguir: escribir nuestra función column-insertion o descubrir si una
existe en Emacs.



Para ver si hay uno en Emacs, se puede usar el comando M-x
apropos. Este comando es como el comando C-h a
(command-apropos), excepto que último encuentra solo estas
funciones que son comandos. El comando M-x apropos lista todos
los símbolos que se asocian a una expresión regular,
incluyendo funciones que no son interactivas.




Lo que queremos buscar es algún comando que imprima o inserte
columnas. Muy probablemente, el nombre de la función contendrá la
palabra `print' o la palabra `insert' o la palabra `column'. Por esta
razón, podemos simplemente escribir M-x apropos RET print
\|insert\|column RET y mira el resultado. En mi sistema, este comando
toma todavía algún tiempo, y entonces produjo una
lista de 79 funciones y variables. Ahora no toma mucho en todo y
produce una lista de 211 funciones y variables. Escaneando la lista,
la única función que mira como si pudiera hacer el trabajo que es
insert-rectangle.



En realidad, esta es la función que queremos; su documentación dice:



 
insert-rectangle:
Insertar texto de RECTANGLE con la esquina izquierda a punto
La primera línea de RECTANGLE es insertada al punto
su segunda línea es insertada a un punto verticalmente
bajo el punto, etc.
El RECTANGLE debería ser una lista de cadenas.
Después de este comando, la marca está en la esquina izquierda
superior y el punto en la esquina derecha inferior.



Se puede ejecutar un test rápido, para asegurar que hace lo que se
espera de eso.



Aquí está el resultado de emplazar el cursor después
de la expresión insert-rectangle y escribiendo C-u C-x
C-e (eval-last-sexp). La función inserta las cadenas
‘"primero"’, ‘"segundo"’, y ‘"tercero"’ en el
punto. Tambiés la función devuelve nil.



 
(insert-rectangle '("primero" "segundo" "tercer"))primero
                                              segundo
                                              terceronil




De acuerdo, nosotros no estaremos insertando el texto de la
expresión insert-rectangle en sí dentro del
búffer en el que estamos marcando el grafo, pero llamará la
función de nuestro programa. Nosotros, sin embargo, tendremos que
asegurar que el punto está en el buffer en el lugar donde la
función insert-rectangle insertará su columna de cadenas.



Si estás leyendo esto en Info, se puede ver como este trabajo cambia
a otro buffer, tal como el buffer ‘*scratch*’, emplazando el
punto a algún lugar en el buffer, escribiendo M-:, escribiendo
la expresión insert-rectangle dentro del minibuffer en la
consola, y entonces escribiendo <RET>. Esto causa Emacs para
evaluar la expresión en el minibuffer, pero usa como el valor del
punto la posición del punto en el buffer
‘*scratch*’. (M-: es el atajo para
eval-expression. También, nil no aparece en el buffer
‘*scratch*’ desde que la expresión es evaluada en el minibuffer.)



Se encuentra cuando hacer esto que punto finaliza al fin de la
última línea insertada --- esto es decir, que esta
función mueve el punto como un efecto lateral. Si nosotros
estábamos para repetir el comando, con el punto en esta posición,
la siguiente inserción sería debajo y a la derecha de
la inserción previa. \textexclamdownNosotros no queremos esto! Si
estamos yendo a crear un gráfico de barras, las columnas necesitan
estar debajo de unas de otras.



Así se descubre que cada ciclo del bucle while
de column-inserting debe reposicionar el punto al lugar que queremos,
y este lugar estará arriba, no abajo, de la columna. Más allá,
se recuerda que cuando se imprime un grafo, no esperan todas las
columnas para estar a la misma altura. Esto significa que el alto de
cada columna puede estar a una altura diferente desde una
previa. Nosotros simplemente reposicionamos el punto a la misma
línea cada vez, pero movido cubriendo a la derecha --- o
quizás se puede …



Estamos planeando crear las columnas de la barra gráfica sin
asteriscos. El número de asteriscos en la columna es el número
específico por el elemento actual del
numbers-list. Necesitamos construir una lista de asteriscos del
tamaño derecho para cada llamada a insert-rectangle. Si esta
lista consiste únicamente del número requerido de asteriscos,
entonces tendremos la posición de punto el número correcto de
líneas bajo la base del gráfico para imprimirse
correctamente. Esto podría ser difícil.



Alternativamente, si podemos figurarnos algún camino para pasar
insert-rectangle una del mismo tamaño cada vez, entonces
podemos posicionar el punto en la misma línea cada vez,
pero se mueve a través de una columna a la derecha por cada nueva
columna. Si hacemos esto, sin embargo, alguna de las entradas en la
lista pasaba a insert-rectangle deben ser espacios en blanco en
vez de asteriscos. Por ejemplo, si la altura máxima del grafo es 5,
pero la altura de la columna es 3, entonces insert-rectangle
requiere un argumento que se parezca a esto:



 
(" " " " "*" "*" "*")




Esta última propuesta no es tan difícil,
así tan largo como podemos determina la altura de la
columna. Hay dos caminos para nosotros especificar la altura de la
columna: se puede arbitrariamente situar que será, lo que
funcionaría bien para gráficas de esta altura; o
podemos buscar a través de la lista de números y usar la altura
máxima de la lista como la altura máxima del grafo. Si la última
operación fuera difícil, entonces el procedimiento
formal sería fácil, pero hay una función construida
en Emacs para determinar el máximo de sus argumentos. Se puede usar
esta función. La función se llamaba max y eso devuelve el
mayor de sus argumentos, que deben ser números. De este modo, por ejemplo,



 
(max  3 4 6 5 7 3)




devuelve 7. (Una función correspondiente llamada min devuelve
lo más pequeño de todos sus argumentos.)





Sin embargo, no podemos simplemente llama a max en el
numbers-list; la función max espera números como sus
argumentos, no una lista de números. De este modo, la siguiente
expresión,



 
(max  '(3 4 6 5 7 3))




produce el siguiente mensaje error;



 
Mal tipo de argumento: number-or-marker-p, (3 4 6 5 7 3)




Se necesita una función que pasa una lista de argumentos a una
función. Esta función es apply. Esta función `aplica' su
primer argumento (una función) para los argumentos que permanecen,
el último puede ser una lista.



Por ejemplo,



 
(apply 'max 3 4 7 3 '(4 8 5))




devuelve 8



(Incidentalmente, yo no sabría como aprender acerca de
esta función sin un libro tal como este. Eso es posible descubrir
otras funciones, como search-forward o insert-rectangle,
adivinando una parte de sus nombres y entonces usando
apropos. Incluso aunque su base metafórica es clara ---
`apply' su primer argumento al resto --- dudo que un novicio
vendría con esta palabra particular usando
apropos u otra ayuda. De acuerdo, podría ser
incorrecto; después de todo, la función fué primero llamada por
alguien quien lo había inventado.



El segundo y subsiguientes argumentos para apply son
opcionales, así se puede usar apply para llamar a
una función y pasan los elementos de una lista, como este, que
también devuelve 8:



 
(apply 'max '(4 8 5))




Este camino tardío es como se usará apply. La
función recurisive-lengths-list-many-files devuelve una lista
de números que se puede aplicar a max (nosotros
podríamos también aplicar (hacer apply) a la
lista de números ordenados; eso no importa si la lista está o no.)



Aquí, la operación para encontrar el tamaño máximo
del grafo es este:



 
(setq max-graph-height (apply 'max numbers-list))




Ahora se puede devolver a la pregunta de como crear una lista de
cadenas para una columna del grafo. Cuenta la máxima altura del
grafo y el número de asteriscos que aparecerían en la
columna, la función devolverá una lista de cadenas para el comando
a insertar insert-rectangle.



Cada columna es hecha de asteriscos o espacios en blanco. Desde que la
función es pasar el valor del alto de la columna y el número de
asteriscos en el columna, el número de espacios en blanco puede ser
encontrado sustrayendo el número de asteriscos desde lo alto de la
columna. Dado el número de espacios en blanco y el número de
asteriscos, dos bucles while puede ser usado para construir la lista:



 
;;; Primera versión.
(defun column-of-graph (max-graph-height actual-height)
  "Devuelve la lista de cadenas que una columna de un grafo."
  (let ((insert-list nil)
        (number-of-top-blanks
         (- max-graph-height actual-height)))



    ;; Llenar asteriscos.
    (while (> actual-height 0)
      (setq insert-list (cons "*" insert-list))
      (setq actual-height (1- actual-height)))



    ;; Rellena espacios en blanco.
    (while (> number-of-top-blanks 0)
      (setq insert-list (cons " " insert-list))
      (setq number-of-top-blanks
            (1- number-of-top-blanks)))



    ;; Devuelve la lista completa.
    insert-list))




Si se instala esta función y entonces evalúa la siguiente
expresión se verá que devuelve la lista como se desea:



 
(column-of-graph 5 3)




devuelve



 
(" " " " "*" "*" "*")




Como está escrito, column-of-graph contiene una grieta mayor:
los símbolos usados para el espacio en blanco para las
entradas marcadas en la columna son `codificadas duras' como un
espacio y un asterisco. Esto está bien para un prototipo, pero tu, u
otro usuario, puede desear usar otros símbolos. Por
ejemplo, chequeando la función grafo, tu quieres usar un periodo en
vez del espacio, asegura el punto que está siendo reposicionando
apropiadamente cada vez que la función insert-rectangle se
llama; o se podría querer sustituir un signo ‘+’ u
otro símbolo para el asterisco. Se podría
incluso querer hacer un graph-column que es más que un ancho de
columna. El programa debería ser más flexible. El
camino para hacer esto es reemplazar el espacio en blanco y el
asterisco con dos variables que se puede llamar graph-blank y
graph-symbol y define estas variables separadamente.



También la documentación no está escrita. Estas consideraciones
nos llevan también a la segunda versión de la función:



 
(defvar graph-symbol "*"
  "Cadena usada como símbolo en grafo, normalmente un asterisco.")



(defvar graph-blank " "
  "La cadena como un espacio en blanco en grafo, normalmente un
  espacio en blanck.
graph-blank debe ser el mismo número de columnas amplio como graph-symbol.")




(Para una explicación de defvar, ver Inicializando una Variable con defvar.)



 
;;; Segunda versión.
(defun column-of-graph (max-graph-height actual-height)
  "Devuelve cadenas MAX-GRAPH-HEIGHT; ACTUAL-HEIGHT son
  símbolos de grafos.


Los graph-symbols son entradas contiguo al fin de la lista. 
La lista será insertado como una columna de un grafo.
Las cadenas son tanto graph-blank o graph-symbol.


  (let ((insert-list nil)
        (number-of-top-blanks
         (- max-graph-height actual-height)))



    ;; Rellenar en graph-symbols.
    (while (> actual-height 0)
      (setq insert-list (cons graph-symbol insert-list))
      (setq actual-height (1- actual-height)))



    ;; Rellenar en graph-blanks.
    (while (> number-of-top-blanks 0)
      (setq insert-list (cons graph-blank insert-list))
      (setq number-of-top-blanks
            (1- number-of-top-blanks)))

    ;; Devuelve la lista completa.
    insert-list))




Si se desea, podríamos reescribir column-of-graph
una tercera vez para proporcionar opcionalmente para una
gráfico de líneas, como gráfico de barras. Esto no
sería duro de hacer. Un camino para pensar en un grafo
de líneas es que no es más que un grafo de barras en
el que la parte de cada barra que está debajo del alto es
blanco. Para construir una columna para gráfico de
líneas, la función primero construyen una lista de
espacios en blanco que es uno más ordenado que el valor, entonces
usa cons para adjuntar un símbolo gráfico a la
lista; entonces eso usa cons de nuevo para adjuntar el `alto de
espacios en blanco' a la lista.



Es fácil ver como escribir tal función, pero desde que no se
necesita eso, no se hará. Pero el trabajo podría ser
hecho, y si eso fuera hecho, eso sería hecho con
column-of-graph. Incluso más importante, no se valora nada
más que pocos cambios que tendría que ser hecho de
cualquier otra manera. La mejora, si nosotros siempre deseamos
hacerla, es simple.



Ahora, finalmente, volvemos a nuestra primera función de grafo
impresa. Esto imprime el cuerpo de un grafo, no las etiquetas para los
ejes horizontal y vertical, así se puede llamar este
graph-body-print.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




15.1 La Función graph-body-print




Después de nuestra preparación en la sección precedente, la
función graph-body-print es simple. La función imprimirá
la columna después de la columna de asteriscos y espacios en blanco,
usando los elemento de la lista de números para especificar el
número de asteriscos en cada columna. Esto es un acto repetitivo,
que significa que se puede usar un bucle while que decrementa o
una función recursiva para el trabajo. En esta sección, se
escribirá la definición usando un bucle while.



La función column-of-graph requiere el alto del grafo como un
argumento, así determinaría y graba esto
como una variable local.



Esto lidera a la siguiente plantilla para el bucle while
versión de esta función:



 
(defun graph-body-print (numbers-list)
  "documentation…"
  (let ((height  …
         …))



    (while numbers-list
      insert-columns-and-reposition-point
      (setq numbers-list (cdr numbers-list)))))




Necesitamos llenar en los slots de la plantilla.



Claramente, se puede usar la expresión (apply 'max
numbers-list) para determinar el alto del grafo.



El bucle while ciclará a través de numbers-list un
elemento a la vez. Como eso está ordenado por la expresión
(setq numbers-list (cdr numbers-list)), el CAR de cada
instancia de la lista es el valor del argumento para column-of-graph.



En cada ciclo del bucle while, la función
insert-rectangle inserta la lista devuelta por
column-of-graph. Desde que la función
insert-rectangle, se necesita guardar la localización de
punto al tiempo que el rectángulo se inserta, mueve atrás a esta
posición después del rectángulo es insertado, y entonces se
mueve horizontalmente al siguiente lugar desde el que
insert-rectangle se llama.



Si las columnas insertadas están en un carácter amplio, como eso
será si los espacios en blanco y asteriscos son usados, el comando
de reposición es simple (forward-char 1); sin embargo, el
ancho de una columna puede ser más grande que uno. Esto significa
que el comando de reposicionamiento sería escrito
(forward-char symbol-width). El mejor lugar para asociar la
variable symbol-width al valor del width de la columna grafo
está en la varlist de la expresión let.



Estas consideraciones lideran a la siguiente definición de función:



 
(defun graph-body-print (numbers-list)
  "Imprime un gráfico de barras de la NUMBERS-LIST.
La numbers-list consiste en los valores del eje Y."

  (let ((height (apply 'max numbers-list))
        (symbol-width (length graph-blank))
        from-position)



    (while numbers-list
      (setq from-position (point))
      (insert-rectangle
       (column-of-graph height (car numbers-list)))
      (goto-char from-position)
      (forward-char symbol-width)

      ;; Dibuja la columna del grafo por columna.
      (sit-for 0)
      (setq numbers-list (cdr numbers-list)))

    ;; Emplaza el punto para etiquetas de ejes X.
    (forward-line height)
    (insert "\n")
))




La expresión inesperada en esta función es la expresión
(sit-for
0) en el bucle while. Esta expresión hace que el grafo
imprima la operación más interesante para vigilar lo que
sería de otro modo. La expresión causa que Emacs pare
(sit-for 0) para un momento cero y entonces redibuje la
pantalla. Puesto aquí, eso causa que Emacs redibuje la
pantalla columna por columna. Sin eso, Emacs no
redibujaría la pantall hasta que la funciń exista.



Se puede chequear graph-body-print con una corta lista de números.



    

  1. 
Instala graph-symbol, graph-blank,
column-of-graph, que están en
and graph-body-print.


  2. 
Copia la siguiente expresión:


     
    (graph-body-print '(1 2 3 4 6 4 3 5 7 6 5 2 3))

    


  3. 
Cambia al búffer ‘*scratch*’ y emplaza el cursor donde quiere
que el grafo empiece.


  4. 
Escribe M-: (eval-expression).


  5. 
Pega la expresión graph-body-print dentro del minibuffer con
C-y (yank).


  6. 
Presiona <RET> para evaluar la expresión graph-body-print




Emacs imprimirá un grafo como este:



 
                    *
                *   **
                *  ****
               *** ****
              ********* *
             ************
            *************









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




15.2 La Función recursive-graph-body-print




La función graph-body-print puede también ser escrito
recursivamente. La solución recursiva es dividida dentro de dos
partes: una fuera `wrapper' envoltorio que usa una expresión
let para determinar los valores varias variables que solo
necesitan ser encontradas una vez, tal como la máxima altura del
grafo, y una función dentro que es llamada recursivamente para
imprimir el grafo.



El `envoltorio' no es complicado:



 
(defun recursive-graph-body-print (numbers-list)
  "Imprime un gráfico de barras del NUMBERS-LIST.
El numbers-list consiste en los valores del eje Y."
  (let ((height (apply 'max numbers-list))
        (symbol-width (length graph-blank))
        from-position)
    (recursive-graph-body-print-internal
     numbers-list
     height
     symbol-width)))




La función recursiva es un poco más difícil. Eso
tiene cuatro partes: el `do-again-test', el código impreso, la
llamada recursiva, y la `next-step-expression'. El `do-again-test' es
una expresión when que determina si el numbers-list
contiene cualquier elementos que permanecen; si hace eso, la función
imprime una columna del grafo usando el código impreso y se llama
así mismo de nuevo. La función llama así
misma de nuevo de acuerco al valor producido por la
`next-steup-expression' que causa para llamar a actuar en una
versión ordenada de la numbers-list.



 
(defun recursive-graph-body-print-internal
  (numbers-list height symbol-width)
  "Imprime un gráfico de barras.
Usado con la función recursive-graph-body-print."



  (when numbers-list
        (setq from-position (point))
        (insert-rectangle
         (column-of-graph height (car numbers-list)))

        (goto-char from-position)
        (forward-char symbol-width)
        (sit-for 0)     ; Dibuja un gráfico columna por columna.
        (recursive-graph-body-print-internal
         (cdr numbers-list) height symbol-width)))




Después la siguiente instalación, esta expresión puede ser
testeado; aquí hay un ejemplo:



 
(recursive-graph-body-print '(3 2 5 6 7 5 3 4 6 4 3 2 1))




Aquí está lo que recursive-graph-body-print produce:



 
                *
               **   *
              ****  *
              **** ***
            * *********
            ************
            *************




Cada una de estas dos funciones, graph-body-print o
recursive-graph-body-print, crea el cuerpo de un grafo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




15.3 Necesidad para Ejes Impresos



Un grafo necesita ejes impresos, así puede orientarse a
tí mimso. Para un proyecto do-once, eso puede ser
razonable dibujar los ejes a mano usando el modo de emacs Picture,
pero un grafo dibuja la función que puede ser usada más de una vez.



Por esta razón, se han escrito mejoras a la función básica
print-graph-body que automáticamente imprime etiquetas para
los ejes horizontal y vertical. Desde la etiqueta de imprimir
funciones no contiene mucho material nuevo, se ha emplazado su
descripción en un apéndice Véase la sección  Un Grafo con Ejes Etiquetados.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




15.4 Ejercicio



Escribe una versión de línea de grafo de la funciones
de impresión del grafo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16. Tu Fichero ‘.emacs’






``No te tiene que gustar Emacs para lo que te gusta'' -- esto parece
una frase paradójica que es el secreto de GNU Emacs. En realidad,
Emacs es una herramienta genérica. La mayoría de la
gente quien lo usa, lo personaliza para ajustarlo a sí
mismos.



GNU Emacs está mayoritariamente escrito en Emacs Lisp; este
significado que escribiendo expresiones en Emacs Lisp se puede cambiar
o extender Emacs.





• Configuración por defecto  



16.1 Fichero de Inicialización Site-wide             Se puede escribir site-wide ficheros init.



16.2 Especificar Variables usando defcustom                  Emacs escribirá código para ti.



16.3 Empieza por un Fichero ‘.emacs’    Cómo escribir un fichero .emacs.



16.4 Modo Texto y Auto Relleno        Corta líneas automáticamente.



16.5 Alias de Correo            Usar abreviaciones para direcciones de correo 
                               electrónico.



16.6 Indentar Modos de Tabulación    No usar tabulaciones con TeX



16.7 Algunos Atajos          Crear algunos atajos de teclado personales.



16.8 Mapas de teclado           Más acerca de atajos de teclado.



16.9 Cargando Ficheros          Cargar (por ej. evaluar) ficheros 
                               automáticamente.



16.10 Autoloading                  Crear funciones disponibles.



16.11 Una Extensión Simple: line-to-top-of-window         Definir una función; enlazarla a una tecla.



16.12 Colores X11                Colores en X.



16.13 Configuraciones Misceláneas para un Fichero ‘.emacs’  



16.14 Una Línea Modificada                  Cómo personalizar tu mode line.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Configuración por Defecto de Emacs



Hay quien aprecia la configuración por defecto de Emacs. Después
de todo, Emacs empieza en modo cuando se edita un fichero C, empieza
en modo Fortran cuando se edita un fichero Fortran, y empieza en modo
Fundamental cuando se edita un fichero no adornado. Esto tiene
sentido, si no sabes quien está yendo a usar Emacs. Quien sabe que
persona espera hacer un fichero no adornado? El modo fundamental es el
derecho por defecto para tal fichero, tal como el modo C es lo
correcto para editar código C. (Suficientes lenguajes de
programación tienen sintaxis que permiten compartir funcionalidades,
tal como el modo C es ahora proporcionado por el modo C, la
`Colección C'.)



Pero cuando se conoce quien está yendo a usar Emacs --- tu, tu mismo
-- entonces eso tiene sentido para personalizar Emacs.



Por ejemplo, yo raramente quiero el modo Fundamental cuando edito un
fichero de otro modo no distinguido; yo quiero el modo Texto. Esto es
por lo que yo personalizo Emacs: así eso se ajusta a
mí.



Se puede personalizar y extender Emacs escribiendo o adaptando un
fichero ‘~/.emacs’. Esto es un fichero de inicialización
personal; sus contenidos, escritos en Emacs Lisp, cuentan a Emacs que
hacer.(13)



Un fichero ‘~/.emacs’ contiene código Emacs Lisp. Se puede
escribir este código por tí mismo; o se puede usar la
funcionalidad customize para escribir el código para ti. Se
puede combinar tus propias expresiones y expresiones auto-escritas
personalizadas en tu fichero ‘.emacs’.



(Yo prefiero por mí mismo escribir mis propias
expresiones, excepto para estas, fuentes particularmente, que se
encuentran fáciles de manipular usando el comando
customize. Yo combino los dos métodos.)



La mayoría de este capítulo es acerca de
escribir expresiones por tí mismo. Eso describe un
fichero ‘.emacs’ simple; para más información, mira
(emacs)Fichero de Inicio sección `El Fichero de Inicio' en El Manual GNU Emacs, y (elisp)Fichero de Inicio sección `El Fichero de Inicio' en El Manual de Referencia GNU Emacs Lisp.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.1 Fichero de Inicialización Site-wide






Además de tu fichero de inicialización personal, Emacs
automáticamente carga varios ficheros de inicialización amplios,
si existen. Estos tienen la misma forma que tu fichero ‘.emacs’,
pero son cargados por cualquiera.



Dos ficheros de incialización, ‘site-load.el’ y
‘site-init.el’, están cargados dentro de Emacs y volcados
dumped si una versión dumped de Emacs se creó, como es
más común. (Las copias dumped de Emacs cargan más
rápidamente. Sin embargo, desde que un fichero se carga y compila,
un cambio no llega a ser un cambio en Emacs a menos que cargues por
tí o recompiles Emacs. Véase (elisp)Construyendo Emacs sección `Construyendo Emacs' en El Manual de Referencia de GNU Emacs Lisp,
y el fichero ‘INSTALL’)



Los tres otros ficheros de inicialización son cargados
automáticamente cada vez que se inicia Emacs, si existen. Esto son
‘site-start.el’, que es cargado antes que tu fichero
‘.emacs’, y ‘default.el’, y el tipo de fichero terminal, que
son cargados después de tu fichero ‘.emacs’.



Las configuraciones y definiciones en tu fichero ‘.emacs’
sobreescribirán las configuraciones en conflicto y definiciones en
un fichero ‘site-start.el’, si eso existe; pero las
configuraciones y definiciones en un ‘default.el’ o tipo de
fichero terminal sobreescribirá estos en tu fichero
‘.emacs’. (Se pueden prevenir interferencias desde un tipo de
fichero terminal configurando term-file-prefix para
nil. Véase la sección  Una Extensión Simple.)



El fichero ‘INSTALL’ que viene en la distribución contiene
descripciones de los fichero ‘site-init.el’ y ‘site-load.el’.



Los ficheros ‘loadup.el’, ‘startup.el’, y ‘loaddefs.el’
controlan la carga. Estos ficheros están en el directorio
‘lisp’ de la distribución Emacs y son valorables por uso.



El fichero ‘loaddefs.el’ contiene buenas sugerencias como las que
poner dentro de tu propio fichero ‘.emacs’, o dentro de un
fichero de inicialización amplio.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.2 Especificar Variables usando defcustom




Se pueden especificar variables usando defcustom
así que tu y otros pueden entoces usar la funcionalidad
de Emacs customize para asignar sus valores. (No se puede usar
customize para escribir definiciones de función; pero se
pueden escribir defuns en tu fichero ‘.emacs’. En vez de
eso, se puede escribir cualquier expresión Lisp en tu fichero
‘.emacs’)



La funcionalidad customize depende de la forma especial
defcustom. Aunque se puede usar defvar o setq
para las variables que los usuarios asignan, la forma especial
defcustom está diseñada para el trabajo.



Se puede usar tu conocimiento de defvar para escribir los
primeros tres argumentos para defcustom. El primer argumento
para defcustom es el nombre de la variable. El segundo
argumento es el valor inicial de la variable, si cualquiera; y este
valor es asignado solo si el valor no ha sido ya asignado. El tercer
argumento es la documentación.



El cuarto y subsiguientes argumentos para defcustom especifican
los tipos y opciones; estas no son fucionales en defvar. (Estos
argumentos son opcionales.)



Cada uno de estos argumentos consiste de una palabra seguido de una
palabra por un valor. Cada palabra clave empieza con los dos puntos
‘:’.



Por ejemplo, la variable de opciones personalizable
text-mode-hook se parece a esto:



 
(defcustom text-mode-hook nil
  "El hook normal se ejecuta cuando se introduce en modo texto y
  muchos modos relacionados."
  :type 'hook
  :options '(turn-on-auto-fill flyspell-mode)
  :group 'data)




El nombre de la variable es text-modo-hook; no tiene valor por
defecto; y su cadena de documentación cuenta lo que hace.



La palabra clave :type le cuenta a Emacs el tipo de datos para
los que text-mode-hook sería asignado y como
muestra el valor en un buffer de Personalización.



La palabra clave :options especifica una lista sugerida de
valores para la variable. Normalmente, :options se aplica a un
gancho. La lista es solo una sugerencia; esa no es exclusiva; una
persona quien asigna la variable puede asignarse a otros valores; la
lista mostrada siguiendo la palabra clave :options se pretende
ofrecer elecciones convenientes a un usuario.



Finalemente, la palabra clave :group cuenta el comando de
Personalización de Emacs en el que el grupo de la variable está
localizado. Esto cuenta dónde encontralo.



La función defcustom reconoce más de una docena de palabras
clave. Para más información, mire (elisp)Personalización sección `Escribiendo las Definiciones de Personalización' en El Manual de Referencia GNU Emacs Lisp.



Considera text-mode-hook como un ejemplo.



Hay dos caminos para personalizar esta variable. Se puede usar el
comando de personalización o escribir la expresiones apropiadas por
tí mismo.



Usando el comando de personalización, se puede escribir:



 
M-x customize




y encuentra que el grupo para editar ficheros datos es llamado
`datos'. Introduce este grupo. El Hook Disparador es el primer
miembro. Se puede hacer click en sus opciones varias, tal como
turn-on-auto-fill, para asignar los valores. Después de hacer
click en el botón.



 
Guárdalo para Futuras Sesiones



Emacs escribirá una expresión en tu fichero ‘.emacs’. Se
parecerá a esto:



 
(custom-set-variables
  ;; custom-set-variables fué añadido por Custom.
  ;; Si se edita a mano, tu podrías liartte,
  así que ten cuidado.
  ;; Tu fichero init contendría solo esta instancia.
  ;; Si hay más de uno, ellos no quieren trabajar.
 '(text-mode-hook (quote (turn-on-auto-fill text-mode-hook-identify))))




(La función text-mode-hook-identify cuenta
toggle-text-mode-auto-fill que buffers hay en modo Texto.  Eso
viene automáticamente)



La función custom-set-variables funciona de alguna manera
diferente más de un setq. Mientras yo nunca he aprendido las
diferencias, yo modifico las expresiones custom-set-variable en
mi fichero ‘.emacs’ a mano: yo creo los cambios en los que
aparecen a mi para ser una manera razonalbe y tener no
problemas. Otros prefieren usar el comando de Personalización y
permitir a Emacs hacer el trabajo para ellos.



Otra función custom-set-… es
custom-set-faces. Esta función asigna varios tipos de
fuentes. A través del tiempo, yo he asignado un considerable
número de tipos. Algo de tiempo, yo las reseteo usando
customize; otras veces, simplemente edito la expresión
custom-set-faces en mi fichero ‘.emacs’ en sí.



El segundo modo de personalizar tu text-mode-hook es asignarte
a tí mismo en tu fichero ‘.emacs’ usando código
que no tiene nada que hacer con las funciones custom-set-….



Cuando se hace esto, y después usa customize, se verá un
mensaje que dice



 
CHANGED fuera de Personalizar; operando dentro aquí
puede ser no confiable.



Este mensaje es solo un aviso. Si se puede cliquear en el botón a



 
Guárdalo para Futuras Sesiones



Emacs escribirá una expresión custom-set-… cerca del
fin de tu fichero ‘.emacs’ que será evaluado después de tu
expresión escrita a mano. Por esta razón, se sobreescribirá tu
expresión escrita a mano. Ningún daño será hecho. Cuando hagas
esto, sin embargo, ten cuidado para recordar que expresión está
activa; si olvidas, puedes confundirte por tí mismo.



Tan largo como se recuerda donde los valores son configurados, no
habrá problemas. En cualquier eventos, los valores son siempre
configurados en tu fichero de inicialización, que es normalmente
llamado ‘.emacs’.



Yo mismo un customize para cualquier cosa. Mayoritariamente,
escribo expresiones por mí mismo.





Incidentalmente, para ser una definición concerniente más
completa: defsubst define una función inline. La sintaxis es
solo como esta de defun. defconst define un
símbolo como una constante. El intento es que ningún
programa o usuario cambiarían un valor asignado por
defconst. (Se puede cambiar; el valor asignado es una variable;
pero por favor no.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.3 Empieza por un Fichero ‘.emacs’




Cuando se empieza Emacs, se carga tu fichero ‘.emacs’ a menos que
se cuente no especificando ‘-q’ en la línea de
comandos. (El comando emacs -q tu da un Emacs plano, fuera.)



Un fichero ‘.emacs’ contiene expresiones Lisp. Con frecuencia, no
hay más expresiones para configura valores; algunas veces esas son
definiciones de funciones.



Véase (emacs)Fichero de Inicio sección `El Fichero de Inicio ‘~/.emacs’' en El Manual GNU Emacs, para una corta descripción de fichero
de inicialización.



Este capítulo cubre algo del mismo suelo, pero es un
paseo entre extractos desde un completo, largamente usado fichero
‘.emacs’ --- por mí.



La primera parte del fichero consiste en comentario: me recuerdo a
mí mismo. Por ahora, de acuerdo, yo recuerdo estas
cosas, pero cuando empecé, no.



 
;;;; fichero .emacs de Bob
; Robert J. Chassell
; 26 de Septiembre de 1985




\'¡Mira en esta fecha! Yo empecé este fichero hace mucho
tiempo. Yo he estado añadiendo cosas desde siempre.



 
; Cada sección en este fichero es introducido por una
; línea empezando con cuatro puntos y comas y cada
; entrada es introducida por una línea empezando con
; tres puntos y comas.



Esto describe las convenciones usuales para comentario en Emacs
Lisp. Cada cosa en una línea que sigue un punto y coma
es un comentario. Dos, tres, y cuatro puntos y coma son usados como
subsección y marcas de sección. (Véase (elisp)Comentarios sección `Comentarios' en El Manual de Referencia GNU Emacs Lisp, para más comentarios.)



 
;;;; La Tecla de Ayuda
; Control-h es la tecla de ayuda;
; después escribiendo control-h, escribe una letra a
; indica el asunto acerca del que quieres ayuda.
; Para una explicación de la facilidad de ayuda,
; escribe control-h dos veces en una fila.




Solo recuerda: escribe C-h dos veces para ayudar.



 
; Para encontrar acerca de cualquier modo, escribe control-h m
; mientras esté en este modo. Por ejemplo, para encontrar
; acerca del modo correo, introduce el modo correo y entonces
; escribe control-h m.



`Modo ayuda', como yo llamo a esto, es muy útil. Usualmente, se
cuenta todo lo que necesitas saber.



De acuerdo, no se necesitan incluir comentarios como estos y fichero
‘.emacs’. Yo los incluí en el mío
poruqe se olvida el Modo ayuda o las convenciones para comentarios ---
pero era capaz de recordar ver aquí recordármelo a
mí mismo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.4 Modo Texto y Auto Relleno



Ahora regresa a la parte que `vuelve' al modo Texto y modo Auto Relleno.



 
;;; Modo texto modo Auto Fill
;; Las siguiente dos líneas puestas en Emacs dentro de
;; modo Texto y en el modo Auto Fill, son para escritores que 
;; quieren empezar a escribir prosa en vez de código.
(setq-default major-mode 'text-mode)
(add-hook 'text-mode-hook 'turn-on-auto-fill)




\textexclamdownAquí está la primera parte de este
fichero ‘.emacs’ que hace alguna cosa bajo recuerdo de un humano
olvidado!



La primera de las dos líneas en paréntesis cuenta a
Emacs cambiar al modo Texto que se encuentra un fichero, a menos
que el fichero iría dentro de algún otro modo, tal
como modo C.







Cuando Emacs lee un fichero, eso parece la extensión al nombre del
fichero. (La extensión es la parte que viene después de un
‘.’.) Si el fichero finaliza con una extensión ‘.c’ o
‘.h’ entonces Emacs cambia al modo C. También, Emacs parece al
principio una línea no blanca del fichero; si la
línea dice ‘-*- C -*-’, Emacs cambia al modo
C. Emacs posee una lista de extensiones y especificaciones que usa
automáticamente. Además, Emacs se ve cerca de la última página
por buffer, ``lista variables locales''.




Ahora, regresa al fichero ‘.emacs’.



Aquí está la línea de nuevo;
¿cḿo trabaja?




 
(setq major-mode 'text-mode)




Esta línea es un resumen, pero completa la expresión
Emacs Lisp.



Ya estamos familiarizados con setq. Eso asigna la siguiente
variable, major-mode, al subsiguiente valor, que es
text-mode. La marca de cita simple antes de text-mode
cuenta a Emacs como tratar directamente con el símbolo,
no con cualquier cosa que pudiera existir. Véase la sección  Configurando el Valor de una Variable, por un recuerdo de como
setq funciona. El principal punto es que no hay diferencia
entre el procedimiento que se usa para asignar un valor en su fichero
‘.emacs’ y el procedimiento que se usa en cualquier lugar más
en Emacs.



Aquí está siguiente línea:





 
(add-hook 'text-mode-hook 'turn-on-auto-fill)




En esta línea, el comando add-hook añade
turn-on-auto-fill para la variable.



turn-on-auto-fill es el nombre de un programa, que, se adivina,
cambia al modo Auto Fill.



Cada vez que Emacs cambia al modo texto, Emacs ejecuta el comando
`hooked' dentro de modo Texto. Así cada vez que Emacs
cambia al modo Texto, Emacs también cambia al modo de autoajuste.



En breve, la primera línea causa a Emacs a entrar en
modo Texto cuando se edite un fichero, a menos que la extensión del
nombre del fichero, una línea no en blanco, variables
locales para contar a Emacs de otro modo.



El modo texto entre otras acciones, asigna la tabla de sintaxis para
trabajar adecuadamente a escritores. En modo texto, Emacs considera
un apóstrofe como parte de una palabra como una letra; pero Emacs no
considera un período o un espacio como parte una
palabra. De este modo, M-f mueve hacia tí a
travé de ‘eso es’. Por otro lado, en modo C, @kdb{M-f} para
solo después del ‘t’ de ‘eso es’.



La segunda línea causa que Emacs activa el modo Auto
Fill cuando cambia al modo Texto. En modo Auto Fill, Emacs
automáticamente rompe una línea que es demasiado
amplio y trae la parte excesivamente amplia de la línea
de debajo a la siguiente línea. Emacs rompe
líneas entre palabras con ellas.



Cuando el modo Auto Fill está desactivado, las líneas
continuan a la derecha como se escriben. Dependiendo de como
configuras el valor de truncate-lines, las palabras que escribe
si desaparecen al lado derecho de la pantalla, o lo demás son
mostradas, en un modo feo e ilegible, como una línea de
continuación en la pantalla.



Además, en este parte de mi fichero ‘.emacs’, yo cuento a Emacs
ajustar comandos para insertar dos espacios después de dos puntos:



 
(setq colon-double-space t)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.5 Alias de Correo



Aquí hay un setq que `activa' alias de correo, a
lo largo de más recuerdos.



 
;;; Modo Correo
; Para entrar en el modo correo, escribe `C-x m'
; Para introducir RMAIL (para leer el correo),
; escribe `M-x rmail'
(setq mail-aliases t)





Este comando setq asigna el valor de la variable
mail-aliases al t. Desde que t significa cierto,
la línea dice, en efecto, ``Sí uso alias
de correo.''



Los alias de correo son nombres cortos convenientes para largas
direcciones de correo o para listas de direcciones de correo. El
fichero donde guardar tus `aliases' es ‘~/.mailrc’. Se escribe
un alias como este:



 
alias geo george@foobar.wiz.edu




Cuando se escribe un mensaje a Jorge, la dirección a ‘geo’; el
correo automáticamente expandirá ‘geo’ a la dirección completa.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.6 Indentar Modos de Tabulación





Por defecto, Emacs inserta tabulaciones en lugar en múltiples
espacios cuando se formatea una región. (Por ejemplo, se
podría indentar muchas líneas de texto
todo a la vez con el comando indent-region.) Los tabuladores se
ven bien en un terminal o con impresión ordinaria, pero ellos
producen mala salida de indentación cuando se usa TeX o Texinfo
desde TeX ignora tabuladores.



Lo siguiente desactiva el modo de Indentar Tabulaciones:



 
;;; Prevenir Tabulaciones Extrañas
(setq-default indent-tabs-mode nil)




Note que esta línea usa setq-default en vez de el
comando setq que hemos visto antes. El comando
setq-default asigna valores solo en buffers que no tienen sus
propios valores locales para la variable.









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.7 Algunos Atajos



Ahora para algunos atajos personales:



 
;;; Compara ventanas
(global-set-key "\C-cw" 'compare-windows)





compare-windows es un comando excelente que compara el texto en
tu ventana actual con texto en la siguiente ventana. Eso hace la
comparación empezando al punto en cada ventana, moviendo a través
del texto en cada ventana tan lejos como ellos asocian. Yo uso este
comando todo el tiempo.



Esto también muestra como configurar una tecla globalmente, para
todo los modos







El comando es global-set-key. Es seguido por el atajo. En un
fichero ‘.emacs’, el atajo es escrito como se ve: \C-c que
se asocia a `control-c', que significa `presionar la tecla de control
y la tecla <c> al mismo tiempo'. La w significa `presionar
la tecla <w>'. El atajo es rodeador por dobles comillas. En la
documentación, se escribiría esto como C-c
w. (Si estuviera asociando una tecla <META>, tal como M-c,
en vez de una tecla de <CTRL>, se escribiría
\M-c en su fichero ‘.emacs’. Véase (emacs)Reasociando Init sección `Reasociando Teclas en Su Fichero Init' en El Manual de GNU Emacs,
para más detalles.)



El comando invocado por las teclas es compare-windows. Note que
compare-windows es precedido por una comilla simple; de otro
modo, Emacs primero intentaría evaluar el
símbolo para determinar su valor.



Estas tres cosas, las marcas de dobles comillas, la barra invertida
antes de la ‘C’, y la marca de comilla simple son partes
necesarias de atajos de teclado que tiendo a olvidar. Afortunadamente,
he llegado a recorda que miraría mi fichero
‘.emacs’ existente, y lo adapta a lo que hay.



Como el atajo en sí: C-c w. Esto combina la tecla
prefija, C-c, con un caracter simple, en este caso,
w. Este conjunto de teclas, C-c seguido por un caracter
simple, es estrictamente reservado para un uso propio
individual. (Esto se llama teclas `propias', desde que estas son para
su propio uso.) Siempre sería capaz de crear tal atajo
para el uso propio sin pisar fuerte en algún atajo más. Si siempre
se escribe una extensión a Emacs, por favor evite tomar cualquier de
estas teclas para uso público. Cree una tecla como C-c C-w en
vez de eso. De otra manera, ejecutará sin sus `propias' teclas.



Aquí hay otro atajo, con un comentario:



 
;;; Atajo para `occur'
; Yo uso mucho occur, así permite asignarlo a una tecla:
(global-set-key "\C-co" 'occur)





El comando occur muestra todas las líneas en el
buffer actual que contiene un emparejamiento para una expresión
regular. Asociar las líneas que se muestran en un
búffer llamado ‘*Occur*’. Este buffer sirve como un menu para
saltar a ocurrencias.






Aquí se muestra como desasignar una tecla,
así no funciona:



 
;;; Desasociar `C-x f'
(global-unset-key "\C-xf")




Hay una razón para esta no asociación: Yo encontré
inadvertidamente escrito C-x f cuando significó escribir
C-x C-f. En vez de encontrar un fichero, como se pretende,
accidentalmente asigna el ancho para el fichero lleno, casi siempre a
un tamaño que no quería. Desde que duramente se
reseteó mi ancho por defecto, yo simplemente disocié la tecla.





Lo siguiente reasocia una tecla existente:



 
;;; Reasocia `C-x C-b' al `buffer-menu'
(global-set-key "\C-x\C-b" 'buffer-menu)




Por defecto, C-x C-b ejecute el comando
list-buffers. Este comando lista sus buffers en otra
ventana. Desde que casi siempre se quiere hacer alguna cosa en esta
ventana, se prefiere el comando buffer-menu, que no solo lista
los buffers, pero mueve el punto dentro de esta ventana.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.8 Mapas de teclado





Emacs usa keymaps para grabar que teclas llaman a qué
comandos. Cuando se use global-set-key para asignar los atajos
de teclados a un simple comando en todo current-global-map.



Modos específicos, tales como modo C o modo Texto, tiene
sus propios mapas de teclado; mapas de teclado de modo
específico sobreescribe el mapa global que es compartido
por todos los buffers.



La función global-set-key asocia, o reasocia, el mapa de
teclado global. Por ejemplo, las siguientes asociaciones la tecla
C-x C-b a la función buffer-menu:



 
(global-set-key "\C-x\C-b" 'buffer-menu)




Mapas de teclado específico de modo son asociados usando
la función define-key, que toma un mapa de teclado
específico como un argumento, tan bien como la tecla y
el comando. Por ejemplo, mi fichero ‘.emacs’ contiene la
siguiente expresión asociada al comando
texinfo-insert-@group comando a C-c C-c g:



 
(define-key texinfo-mode-map "\C-c\C-cg" 'texinfo-insert-@group)




La función texinfo-insert-@group en sí es una
pequeña extensión a modo Texinfo que inserta ‘@group’ dentro
de un fichero Texinfo. Yo uso este comando todo el tiempo y prefiero
escribir los tres atajos C-c C-c g en vez de los seis atajos
@ g r o u p. (‘@group’ y su asociación ‘@end
group’ son comandos que guarda todo el texto cerrado junto en una
página; muchos ejemplos multi-línea en este libro
están rodeados por ‘@group @dost{} @end group’.)



Aquí está la definición de función
texinfo-insert-@group:



 
(defun texinfo-insert-@group ()
  "Inserta la cadena @group en un buffer Texinfo."
  (interactive)
  (beginning-of-line)
  (insert "@group\n"))




(De acuerdo, podría haber usado el modo Abbrev para
dejar de escribir, en vez de escribir una función para insertar una
palabra; pero prefiero atajos de teclado consitentes con otro modo
Texinfo para atajos de teclado.)



Verá numerosas expresiones define-key en ‘loaddefs.el’
tan bien como en varios modos de librerías, tal como
‘cc-mode.el’ y ‘lisp-mode.el’.



Véase (emacs)Atajos de Teclado sección `Personalizando Atajos de Teclado' en El Manual GNU Emacs, y (elisp)Mapas de Teclado sección `Mapas de Teclado' en El Manual de Referencia GNU Emacs Lisp, para más
información acerca de mapas de teclado.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.9 Cargando Ficheros




Muchas personas en la comunidad de GNU Emacs han escrito extensiones a
Emacs. Hace tiempo, que estas extensiones son con frecuencia incluidas
en las nuevas entregas releases. Por ejemplo, los paquetes
Calendario y Diario son ahora parte del estándar GNU Emacs, como es Calc.



Se puede usar un comando load para evaluar un fichero completo
que significa instalar todas las funciones y variables en el fichero
Emacs. Por ejemplo:




 
(load "~/emacs/slowsplit")




Esto evalúa, por ej. cargaa, el fichero ‘slowsplit.el’ o si
eso existe, lo más rápido, el fichero compilado
‘slowsplit.elc’ desde el subdirectorio ‘emacs’ del
directorio home. El fichero contiene la función
split-window-quietly, que John Robinson escribió en 1989.



La función split-window-quietly divide una ventana con el
mínimo de redisplay. Yo lo instalé en 1989 porque
trabajó bien con los terminales de 1200 baudios que entonces estaba
usando. Ahora, ocasionalmente vengo a través de una conexión
lenta, pero continuao usando la función porque me gusta el camino
que deja arriba del búffer en el bajo de las nuevas ventanas y
arribaa en la ventana superior. 



Para reemplazar el atajo de teclado por defecto
split-window-vertically, se debe también desasignar esta
tecla y asociar las teclas a split-window-quietly, como este:



 
(global-unset-key "\C-x2")
(global-set-key "\C-x2" 'split-window-quietly)





Si se cargan muchas extenisones, como yo hago, entonces en vez de
especificar la posición exacta del fichero, como se muestra arriba,
se puede especificar que directorio como parte del load-path de
Emacs. Entonces, cuando Emacs carga un fichero, buscará que
directorio tan bien como su lista por defecto de directorios. (La
lista por defecto es especificada en ‘paths.h’ cuando Emacs es
construida.)



El comando siguiente añade tu directorio ‘~/emacs’ a la ruta
existente:



 
;;; Ruta Emacs
(setq load-path (cons "~/emacs" load-path))




Incidentalmente, load-library es un interfaz interactivo a la
función load. La función se parece a esto:




 
(defun load-library (library)
  "Carga la librería llamada LIBRARY.
Esto es una interfaz `load'."
  (interactive
   (list (completing-read "Load library: "
			  (apply-partially 'locate-file-completion-table
                                           load-path
                                           (get-load-suffixes)))))
  (load library))




El nombre de la función, load-libray, viene desde el uso de
`library' como un sinónimo para `file'. La fuente para el comando
load-library está en la librería ‘files.el’.



Otro comando interactivo que hace un trabajo ligeramente diferente es
load-file. Véase (emacs)Librerías Lisp sección `Librerías de Código Lisp para Emacs' en El Manual GNU Emacs, para información en la distinción entre
load-library y este comando.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.10 Autoloading




En vez de instalar una función cargando el fichero que lo contiene,
o evaluando la definición de función, se puede hacer la función
disponible pero actualmente no se instala hasta la primera vez
llamada. Esto es llamado autocarga.



Cuando se ejecuta una función de autocarga, Emacs automáticamente
evalúa el fichero que contiene la definición, y entonces llama a
la función.



Emacs empieza rápido con funciones de autocarga, desde sus
librerías son no cargadas bien; pero si necesita esperar
un momento cuando su primer uso tal como una función, mientras el
fichero que lo contiene es evaluado.



Raramente las funciones usadas son frecuentemente autocargados. La
librería ‘loaddefs.el’ coniene cientos de funciones
autocargadas, desde bookmark-set a wordstar-mode. De
acuerdo, se puede venir a usar una función `rara'
frecuentemente. Cuando se hace, se debería cargar este
fichero de función con una expresión de load en tu fichero
‘.emacs’.



En mi fichero ‘.emacs’, se cargan 14 librerías que
contienen funciones que de otro modo serían
autocargadas. (Actualmentem, eso habría sido mejor para
incluir estos ficheros en mi Emacs `volcado', pero se
olvida. Véase (elisp)Construyendo Emacs sección `Construyendo Emacs' en El Manual de Referencia GNU Emacs Lisp, y el fichero ‘INSTALL’ para
más acerca de volcados.)



Se puede también querer incluir expresiones autocargadas en tu
fichero ‘.emacs’. autoload es una función construida que
toma cinco argumento, los tres finales de los que son opcionales. El
primer argumento es el nombre de la función para ser autocargada; el
segundo es el nombre del fichero para ser cargados. El tercer
argumento es documentación para la función, y el cuarto cuenta si
la función puede ser llamada interactivmente. El quinto argumento
cuenta que tipo de objeto --- autoload puede manejar un mapa de
teclado o macro tan bien como una función (por defecto es una función).



Aquí hay un ejemplo típico:



 
(autoload 'html-helper-mode
  "html-helper-mode" "Editar documentos HTML" t)




(html-helper-mode es una vieja alternativa a html-mode,
que es un parte estándar de la distribución.)



Esta expresión autocarg la función html-helper-mode. Esto
lo toma desde el fichero ‘html-helper-mode-el’ (o desde la
versión compilada ‘html-helper-mode.elc’, si esto existe.) El
fichero debe ser localizada en un directorio específico
por load-path. La documentación dice que esto es un modo para
ayudarte a editar documentos escritos en Lenguaje de Marcas de Hiper
Texto. Se puede llamar este modo interactivamente escribiendo M-x
html-helper-mode. (Necesitas duplicar las funciones regulares de
documentación en la expresión de autocarga porque la función
regular no está todavía cargada, así su
documentación no está disponible.)



Véase (elisp)Autocarga sección `Autocarga' en El Manual de Referencia de GNU Emacs Lisp, para más información.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.11 Una Extensión Simple: line-to-top-of-window





Aquí hay una simple extensión a Emacs que mueve el
punto de línea arriba de la ventana. Yo uso esto todo el
tiempo, para hacer fácil leer el texto.



Se puede poner el siguiente cd'igo dentro de un fichero separado y
entonce cargarlo desde tu fichero ‘.emacs’, o se puede incluir
con tu fichero ‘.emacs’.



Aquí es la definición



 
;;; Línea a lo alto de la ventana;
;;; reemplaza tres secuencias de atajos de teclado  C-u 0 C-l
(defun line-to-top-of-window ()
  "Mueve la línea que apunta a lo alto de la ventana."
  (interactive)
  (recenter 0))




Ahora el atajo.



En estos días, las teclas de función así
como los eventos del ratón y caracteres no ASCII son escritos
con corchetes, sin marcas de citas. (En Emacs versión 18 y antes, se
tenía que escribir diferentes teclas de función
asignadas por cada diferente creación del terminal.)



Yo asocio line-to-top-of-window a mi función <F6> como esta:



 
(global-set-key [f6] 'line-to-top-of-window)




Para más información, mira (emacs)Reasociando el Init sección `Reasociando Tecls en tu fichero init' en El Manual GNU Emacs.






Si ejecutas dos versiones de GNU Emacs, tal como las versiones 22 y
23, y usa un fichero ‘.emacs’, se puede seleccionar que código
para evaluar el siguiente condicional:



 
(cond
 ((= 22 emacs-major-version)
  ;; evalúa la version 22
  ( … ))
 ((= 23 emacs-major-version)
  ;; evalúa la version 23 
  ( … )))




Por ejemplo, en contraste a la versión 20, versiones más recientes
ocultan sus cursores por defecto. Se odia tal ocultación, tanto como
otras funcionalidades, así se emplaza lo siguiente en mi
fichero ‘.emacs’(14):



 
(when (>= emacs-major-version 21)
  (blink-cursor-mode 0)
  ;; Inserta la nueva línea cuando se presiona `C-n' (next-line)
  ;; al fin del búffer
  (setq next-line-add-newlines t)

  ;; Cambia la imagen viendo
  (auto-image-file-mode t)

  ;; Activa la barra de menu (esta barra tiene texto)
  ;; (Usa un argumento numérico para activarlo)
  (menu-bar-mode 1)

   ;; Desactiva la barra de herramientas (esta barra tiene iconos)
   ;; (Usa argumentos numéricos para activarlo)
   (tool-bar-mode nil)

  ;; Desactiva el modo tooltip para la tool bar
  ;; (Este modo causa explicaciones de iconos al pop up)
  ;; (Usa el argumento numérico para activarlo)
  (tooltip-mode nil)
  ;; Si los tooltips activados, crea consejos aparecen en el prompt
  (setq tooltip-delay 0.1)  ; por defecto es de 0.7 segundos
   )









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.12 Colores X11



Se pueden especificar colores cuando se usa Emacs con el Sistema de
Ventanas X del MIT.



Me disgustan los colores de por defecto y especificar los
míos.



Aquí están las expresiones en mi fichero ‘.emacs’
que establecen valores:



 
;; Asigna el color del cursor
(set-cursor-color "white")

;; Asigna el color del ratón
(set-mouse-color "white")

;; Asigna foreground y background
(set-foreground-color "white")
(set-background-color "darkblue")



;;; Asigna colores para isearch y drag
(set-face-foreground 'highlight "white")
(set-face-background 'highlight "blue")



(set-face-foreground 'region "cyan")
(set-face-background 'region "blue")



(set-face-foreground 'secondary-selection "skyblue")
(set-face-background 'secondary-selection "darkblue")



;; Asigna colores al calendario
(setq calendar-load-hook
      '(lambda ()
         (set-face-foreground 'diary-face   "skyblue")
         (set-face-background 'holiday-face "slate blue")
         (set-face-foreground 'holiday-face "white")))




Las varias sombras de azul disparan mi ojo y me preveen de ver la
ventana desplegada.



Alternativamente, se podrían haber configurado mis
especificaciones en varios ficheros inicialización de X. Por
ejemplo, se podría asignar el foreground, background,
cursor y puntero (por ej., ratón) colores en mi fichero
‘~/.Xresources’ como esto:



 
Emacs*foreground:   white
Emacs*background:   darkblue
Emacs*cursorColor:  white
Emacs*pointerColor: white




En cualquier evento que no es parte de Emacs, se asigna el color
raíz de mi ventana X en mi fichero ‘~/.xinitrc’,
como este(15)



 
xsetroot -solid Navy -fg white &









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.13 Configuraciones Misceláneas para un Fichero ‘.emacs’



Aquí hay unas pocas configuraciones misceláneas:








Arreglando Atajos de Teclados





Algunos sistemas asocian teclas de maneras no agradables. Algunas
veces, por ejemplo, la tecla <CTRL> en un modo perverso en vez de
la lejanía a la izquierda de la fila.



Normalmente, cuando las personas arreglan estos atajos de teclado, no
se cambia su fichero ‘~/.emacs’. En vez de eso, se asocian las
teclas apropiadas en sus consolas con los comandos loadkeys o
install-keymap en su script de inicio y entonces incluyen
comandos xmodmap en su fichero ‘.xinitrc’ o
‘.Xsession’ para X Windows.



Para un script de inicio:



 
loadkeys /usr/share/keymaps/i386/qwerty/emacs2.kmap.gz
or
install-keymap emacs2




Para un fichero ‘.xinitrc’ o un fichero ‘.Xsession’ cuando la
tecla <Caps Lock> es que tan lejos de la fila del home:



 
# Asocia la tecla etiquetada `Caps Lock' a `Control'
# (Tal como un interfaz de usuario roto sugiere que el teclado hecho
# piensa que los ordenadores son máquinas de escribir desde 1885.)

xmodmap -e "clear Lock"
xmodmap -e "add Control = Caps_Lock"




En un ‘.xinitrc’ o ‘.Xsession’, para convertir una tecla
<ALT> a una tecla <META>:



 
# Algunos teclados mal diseñados tienen una tecla etiquetada ALT y no Meta
xmodmap -e "keysym Alt_L = Meta_L Alt_L"








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




16.14 Una Línea Modificada





Finalmente, una funcionalidad que realmente me gusta: un mode line
modificado.



Cuando se trabaja a través de una red, se olvida que máquina se
está usando. También, se tiende a perder la traza de donde se
está, y a que línea se apunta.



Así se resetea mi mode line para que se parezca a esto:



 
-:-- foo.texi   rattlesnake:/home/bob/  Line 1  (Texinfo Fill) Top




Estoy visitando un fichero llamado ‘foo.texi’, en mi máquina
‘rattlesnake’ en mi búffer ‘/home/bob’. Yo estoy on line
1, en modo Texinfo, y estoy arriba del búffer.



Mi fichero ‘.emacs’ tiene una sección que se parece a esto:



 
;; Asigna un Mode Line que nos cuente que máquina, que directorio, 
;; y que línea estoy on, más la información de client.
(setq-default mode-line-format
 (quote
  (#("-" 0 1
     (help-echo
      "mouse-1: select window, mouse-2: delete others ..."))
   mode-line-mule-info
   mode-line-modified
   mode-line-frame-identification
   "    "

   mode-line-buffer-identification
   "    "
   (:eval (substring
           (system-name) 0 (string-match "\\..+" (system-name))))
   ":"
   default-directory
   #(" " 0 1
     (help-echo
      "mouse-1: select window, mouse-2: delete others ..."))
   (line-number-mode " Line %l ")
   global-mode-string

   #("   %[(" 0 6
     (help-echo
      "mouse-1: select window, mouse-2: delete others ..."))
   (:eval (mode-line-mode-name))
   mode-line-process
   minor-mode-alist
   #("%n" 0 2 (help-echo "mouse-2: widen" local-map (keymap ...)))
   ")%] "
   (-3 . "%P")
   ;;   "-%-"
   )))




Aquí, se redefine el mode line por defecto. La
mayoría de las partes son desde el original; pero yo
creo unos pocos cambios. Yo asigno el formato de mode line
default así como permitir varios modos, tales
como Info, para sobreescribirlo.



Muchos elementos en la lista son auto-explicativos:
mode-line-modified es una variable que cuenta si el búffer ha
sido modificado, mode-name cuenta el nombre del modo, y
así. Sin embargo, el formato parece complicado porque
las dos funcionalidades no han sido discutidas.






La nueva cadena de formato tiene una sintaxis especial:



 
#("-" 0 1 (help-echo "mouse-1: select window, ..."))




El #( empieza una lista. El primer elemento de la lista es la
cadena en sí, solo un ‘-’. El segundo y tercer
elemento especifica el rango a través con el cuarto elemento
aplicado. Un rango empieza después un carácter,
así un cero significa el rango que empieza solo
después del primer caracter; un 1 significa que el rango finaliza
solo después del primer caracter. El tercer elemento es la propiedad
para el rango. Eso consiste en una lista de propiedades, un nombre de
propiedad, en este caso, ‘help-echo’, seguido por un valor, en
este caso, una cadena. El segundo, tercer y cuarto elementos de esta
nuevo formato de cadena puede ser repetido.



Véase (elisp)Propiedades de Texto sección `Propiedades de Texto' en El Manual de Referencia de GNU Emacs Lisp, y ver (elisp)Formato Mode Line sección `Formato Mode Line' en El Manual de Referencia de GNU Emacs Lisp,
para más información.



mode-line-buffer-identification muestra el nombre del
buffer. Eso es una lista empezando por (#("%12b" 0 4
…. El #( empieza la lista.



El ‘\"%12b\"’ muestra el nombre del actual búffer, usando la
función buffer-name con la que estamos familiarizados; el
`12' especifica el número máximo de caracteres que serán
mostrados. Cuando un nombre tiene pocos caracteres, el espacio en
blanco se añade para rellenar este número. (Los nombres del
búffer puede y con frecuencia serían más largos de
12 caracteres; esta longitud funciona bien en la típica
ventana de 80 columnas de ancho.)



:eval dice evaluar la siguiente forma y usa el resultado como
una cadena para mostrarse. En este caso, la expresión muestra el
primer componente del sistema completo. El fin del primer componente
es un ‘.’ (`periodo'), así se usa la función
string-match para contar el tamaño del primer componente. La
subcadena desde el caracter cero a este tamaño del primer
componente. La subcadena desde el caracter cero a este tamaño es el
nombre de la máquina.



Esta es la expresión:



 
(:eval (substring
        (system-name) 0 (string-match "\\..+" (system-name))))




‘%[’ y ‘%]’ causa un par de corchetes que aparezcan por cada
edición nivel de edición recursiva editando el nivel. ‘%n’
dice `Encoger' cuando esto puede hacerse. ‘%P’ te cuenta el
porcentaje del buffer que está debajo debajo de la ventana, o
`arriba', `abajo', o `todo'. (Una minúscula ‘p’ cuenta el
porcentaje bajo el alto de la ventana.) ‘%-’ inserta suficientes
guiones para rellenar la línea.



Recuerda, ``No tiene que gustarte Emacs para que le gustes'' --- tu
Emacs puede tener diferentes colores, diferentes comandos, y
diferentes teclas que un Emacs por defecto.



Por otro lado, si se quiere traer un plano `fuera de la caja' Emacs,
sin personalización, escribe:



 
emacs -q




Esto inicializará un Emacs que no cargue tu ‘~/.emacs’
fichero de inicialización. Uno plano, el que trae Emacs por
defecto. Nada más.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




17. Depurando




GNU Emacs tiene dos depuradores, debug y edebug. El
primero es construido dentro de las trips de Emacs y está siempre
contigo; el segundo requiere que tu instrumente una función ante de
que se pueda usar.



Ambos depuradores son descritos extensivamente en (elisp)Depurando sección `Depurando Programas Lisp' en El Manual de Referencia GNU Emacs Lisp. En este capítulo, se explicará un corto ejemplo
de eso.





17.1 depurar                    Cómo usar el depurador construido.



17.2 debug-on-entry             Empezar depurando cuando se llama a una 
                               función.



17.3 debug-on-quit y (debug)              Empezar depurando cuando se sale con C-g.



17.4 El Depurador de Nivel de Fuentes edebug                     Cómo usar Edebug, un depurador a nivel de 
                               fuentes.



17.5 Ejercicios de Depuración    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




17.1 depurar




Supón que se ha escrito una definición de función que se
pretende devolver la suma de los números 1 a través de un número
dado. (Esta es la función triangle discutida
pronto. @xref{Ejemplo de Decremento, , Ejemplo con Contador de
Decremento}, para una discusión.)



Sin embargo, tu definición de función tiene un error. Se ha
malescrito ‘1=’ por ‘1-’. Aquí está la
definición rota:




 
(defun triangle-bugged (number)
  "Devuelve suma de números 1 a través de NUMBER inclusive."
  (let ((total 0))
    (while (> number 0)
      (setq total (+ total number))
      (setq number (1= number)))      ; Error aquí.
    total))




Si se está leyendo esto en Info, se puede evaluar esta definición
en el modo normal. Se verá triangle-bugged aparece en el
área echo.



Ahora evalúa la función triangle-bugged con un argumento de
4:



 
(triangle-bugged 4)




En un GNU Emacs reciente, se creará e introducirá un búffer
‘*Bactrace*’ que dice:



 
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function 1=)
  (1= number)
  (setq number (1= number))
  (while (> number 0) (setq total (+ total number))
        (setq number (1= number)))
  (let ((total 0)) (while (> number 0) (setq total ...)
    (setq number ...)) total)
  triangle-bugged(4)

  eval((triangle-bugged 4))
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------




(Se ha reformateado este ejemplo ligeramente; el depurador no contiene
muchas líneas. Así, se puede salir del
depurador escribiendo q en el buffer ‘*Backtrace*’.)



En la práctica, por un error tan simple como este, la
línea de `error Lisp' contará que se necesita saber
para corregir la definición. La función 1= es
`vacía'.




Sin embargo, supón que no estás con bastante certeza de lo que
está pasando. Se puede leer la traza completa.



En este caso, se necesita ejecutar una versión reciente de GNU
Emacs, que automáticamente empieza el depurador que pone en el
búffer ‘*Backtrace*’; o además, se necesita para empezar el
depurador manualmente como se describe debajo.



Lee el buffer ‘*Bactrace*’ de abajo a arriba; eso cuenta lo que
le hizo a Emacs tener un error. Emacs hace una llamada interactiva a
C-x C-e (eval-last-sexp), que lleva a la evaluación de
la expresión triangle-bugged. Cada línea de
debajo cuenta lo que el intérprete Lisp evaluó.



La tercera línea desde lo alto del búffer es



 
(setq number (1= number))




Emacs intentó evaluar esta expresión; en orden para hacerlo
así, eso intentó evaluar la expresión propia mostrar
en la segunda línea desde arriba:



 
(1= number)




Esto es donde el error ocurrió; como en la línea alta dice:



 
Debugger entered--Lisp error: (void-function 1=)




Se puede corregir el error, reevalúa la definición de función, y
entonces se puede testear de nuevo.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




17.2 debug-on-entry




Un GNU Emacs reciente empieza el depurador autmomáticamente cuando
tu función tiene un error.




Incidentalmente, se puede empezar el depurador manualmente para todas
las versiones de Emacs; la ventaja es que el depurador se ejecuta
incluso si no se tiene un error en su código. Algunas veces,
\textexclamdownsu código estará libre de errores!



Se puede introducir el depurador cuando se llama a la función
llamando debug-on-entry.



Tipo:



 
M-x debug-on-entry RET triangle-bugged RET




Ahora, evalúa lo siguiente:



 
(triangle-bugged 5)




Todas las versiones de Emacs crearán un búffer ‘*Backtrace*’
y cuenta tu que eso es el principio para evaluar la función
triangle-bugged:



 
---------- Buffer: *Backtrace* ----------
Debugger entered--entering a function:
* triangle-bugged(5)
  eval((triangle-bugged 5))

  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------




En el buffer ‘*Backtrace*’, escribe d. Emacs evaluará la
primera expresión en triangle-bugged; el buffer se parece a esto:



 
---------- Buffer: *Backtrace* ----------
Debugger entered--beginning evaluation of function call form:
* (let ((total 0)) (while (> number 0) (setq total ...)
        (setq number ...)) total)
* triangle-bugged(5)
  eval((triangle-bugged 5))

  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------




Ahora, escribe d de nuevo, ocho veces, lentamente. Cada vez que
se escribe d Emacs se evaluará otra expresión en la
definición de función.



Eventualmente, el búffer se parece a esto:



 
---------- Buffer: *Backtrace* ----------
Debugger entered--beginning evaluation of function call form:
* (setq number (1= number))
* (while (> number 0) (setq total (+ total number))
        (setq number (1= number)))

* (let ((total 0)) (while (> number 0) (setq total ...)
        (setq number ...)) total)
* triangle-bugged(5)
  eval((triangle-bugged 5))

  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------




Finalmente, después escribe d dos veces más, Emacs logrará
el error y las dos líneas superiores del buffer
‘*Backtrace*’ se ve así:



 
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function 1=)
* (1= number)
…
---------- Buffer: *Backtrace* ----------




Escribiendo d, sería capaz de pasear a través de
la función.



Se puede salir de un buffer ‘*Backtrace*’ escribiendo q;
esto se sale de la traza, pero no cancela debug-on-entry.




Para cancelar el efecto de debug-on-entry, llama a
cancel-debug-on-entry y el nombre de la función, como esto:



 
M-x cancel-debug-on-entry RET triangle-bugged RET




(Si estás leyendo esto en Info, cancela debug-on-entry ahora.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




17.3 debug-on-quit y (debug)



Adición a la configuración debug-on-error o llamando
debug-on-entry, hay otros dos caminos para empezar debug.




Se puede empezar debug siempre y cuando se escribe C-g
(keyboard-quit) se configura la variable debug-on-quit
para t. Esto es útil para depurar bucles infinitos.




O, se puede insertar un línea que dice (debug)
dentro de tu código donde se quiere que el depurador empiece, como esto:



 
(defun triangle-bugged (number)
  "Devuelve suma de números 1 a través de NUMERO inclusive."
  (let ((total 0))
    (while (> number 0)
      (setq total (+ total number))
      (debug)                         ; Start debugger.
      (setq number (1= number)))      ; Error here.
    total))




La función debug es descrita en detalle en (elisp)Depurador sección `El Depurador Lisp' en El Manual de Referencia GNU Emacs Lisp.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




17.4 El Depurador de Nivel de Fuentes edebug





Edebug es un depurador a nivel de fuentes Edebug normalmente muestra
las fuentes del código que se está depurando, con una flecha a la
izquierda que muestra que línea se está actualmente
ejecutando.



Se puede pasear a través de la ejecución de una función,
línea a línea, o ejecutarse rápidamente
hasta lograr un punto de ruptura donde la ejecución pare.



Edebug es descrito en (elisp)edebug sección `Edebug' en El Manual de Referencia de GNU Emacs Lisp.



Aquí hay una función con errores para
triangle-recursively. @xref{Funci@'on Recursiva Tri@'angulo, ,
Recursi@'on en lugar de un contador}, para una revisión de eso.



 
(defun triangle-recursively-bugged (number)
  "Devuelve la suma of números 1 a través de NUMBER inclusive.
Usa recursión."
  (if (= number 1)
      1
    (+ number
       (triangle-recursively-bugged
        (1= number)))))               ; Error aquí.




Normalmente, se instalaría esta definición
posicionando su cursor después de la función cerrando paréntesis
y escribiendo C-x C-e (eval-last-sexp) o lo demás
posicionando tu cursor con la definición y escribiendo C-M-x
(eval-defun). (Por defecto, el comando eval-defun
funciona solo en modo Emacs Lisp o en el modo de interacción de
Lisp.)



Sin embargo, para preparar esta definición de función para Edebug,
se debe primero instrumentar el código usando un comando
diferente. Se puede hacer esto posicionando su cursos con o solo
después de la definición y escribiendo



 
M-x edebug-defun RET




Esto causará que Emacs cargue Edebug automáticamente si eso no
está ya cargado, y apropiadamente instrumenta la función.



Después de instrumentar la función, emplaza tu cursor después
de la siguiente expresión y escribe C-x C-e (eval-last-sexp):



 
(triangle-recursively-bugged 3)




Se volverá a las fuentes de triangle-recursively-bugged y el
cursor posicionó al principio del if línea de
la función. También, verá una flecha a la mano izquierda al
lado de esta línea donde la función se está
ejecutando. (En los siguientes ejemplos, se muestra la flecha con
‘=>’; en un sistema de ventanas, se puede ver la flecha como un
triángulo sólido en el `borde' de la ventana.)



 
=>∗(if (= number 1)




En el ejemplo, la localización del punto es mostrado como
‘∗’ (en un libro impreso, eso es mostrado con una estrella
apuntada).



Si ahora presiona <SPC>, el punto moverá a la siguiente
expresión para ser ejecutado; la línea se parece a esto:



 
=>(if ∗(= number 1)




Como se continua presionando <SPC>, el puntero se moverá desde
la expresión a la expresión. Al mismo tiempo, siempre y cuando una
expresión devuelva un valor, este valor será mostrado en el área
echo. Por ejemplo, después de mover el punto pasado number,
se verá lo siguiente:



 
Resultado: 3 (#o3, #x3, ?\C-c)




Esto significa el valor de number es 3, que son tres octales,
tres hexadecimales, y ASCII `control-c' (la tercera letra del
alfabeto, en caso de que necesites conocer esta información).



Se puede continuar moviendo a través del código hasta que logres
la línea con el error. Antes de la evaluación, esta
línea se parece a esto:



 
=>        ∗(1= number)))))               ; Error aquí.




Cuando se presiona <SPC> una vez de nuevo, se producirá un
mensaje de error que dice:



 
La definición de la función está vacío: 1=



Este es el error.



Presiona q para salir de Edebug.



Para eliminar la instrumentación desde una definición de
función, simplemente reevalúalo con un comando que no lo
instrumente. Por ejemplo, se podría posicionar su cursor
después de la definición cerrando paréntesis y escribe C-x
C-e. 



Edebug hace un gran trato más antes de entrar en una función. Se
puede asignar así conducir a sí mismo,
parando solo en un error o en punto específicos, se
puede causar para mostrar los valores cambiantes de varias
expresiones; se puede encontrar cuantas veces una función es
llamada, y más.



Edebug es descrito en (elisp)edebug sección `Edebug' en El Manual de Referencia de GNU Emacs Lisp.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




17.5 Ejercicios de Depuración










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




18. Conclusión



Ahora hemos logrado el fin de esta Introducción. Tu has aprendido lo
suficiente acerca de programación en Emacs Lisp para asignar
valores,l para escribir ficheros ‘.emacs’ por tí
mismo y tus amigos, y escribe personalizaciones simples y extensiones
a Emacs.



Este es un lugar para parar. O, si lo deseas, se puede ir adelante, y
enseñarte a tí mismo.



Se han aprendido algunas bases de programación. Pero solo
algunas. Todavía hay mucho que es fácil de usar que no
se ha tocado.



Una ruta que se puede seguir bien, ahora cae entre las fuentes para
GNU Emacs y dentro
El Manual de Referencia de GNU Emacs.



Las fuentes de Emacs Lisp son una aventura. Cuando se leen las fuentes
vienen a través de una función o expresión que no es familiar,
se necesita imaginar o encontrar qué hace.



Ir al Manual de Referencia. Eso está a través del completo, limpio
y fácil de leer descripción de Emacs Lisp. Está escrito no solo
para expertos, pero sí para gente que conoce lo que tu
conoce. (El Manual de Referencia viene con la distribución de
GNU Emacs. Como esta introducción, eso viene como un fichero fuente
Texinfo, así se puede leer on-line como un libro impreso.)



Ir a otra ayuda on-line que es parte de GNU Emacs: la documentación
on-line para todas las funciones y variables, y find-tag, el
programa que te toma a las fuentes.



Aquí hay un ejemplo de cómo explorar las
fuentes. Porque su nombre, ‘simple.el’ es el fichero que se vió
primero, hace tiempo. Como eso ocurre alguna de las funciones en
‘simple.el’ son complicadas, o al menos parece complicado a
primera vista. La función open-line, por ejemplo, parece
complicado.



Se puede querer pasear a través de esta función lentamente, como
nosotros hicimos la función
forward-sentence. (Véase La función forward-sentence.) O se puede querer escapar de esta función y mira en otra: (la función split-line contiene 102 palabras y símbolos. Incluso aunque es corto)forward-sentence sección `tal como split-line. No se necesita leer todas las funciones. De acuerdo a count-words-in-defun' en split-line contiene expresiones no hemos estudiado: skip-chars-forward, indent-to, current-column y insert-and-inherit. Considera la función skip-chars-forward. (Eso es parte de la definición de función para back-to-indentation, que es mostrado Revisar.) En GNU Emacs, se puede encontrar más acerca de skip-chars-forward escribiendo C-h f (describe-function) y el nombre de la función. Esto te da la documentación de función. Se puede ser capaz de adivinar que es hecho por una función bien llamada tal como indent-to; o se puede buscar, tambión. Incidentalmente, la función describe-function en sí está en ‘help.el’; eso es uno de estos largos, pero funciones descifrables. Se puede buscar describe-function usando el comando C-h f! En esta instancia, desde el código es Lisp, el búffer ‘*Help*’ contiene el nombre de la librería conteniendo las fuentes de la función. Se puede poner el punto a través del nombre de la librería y presiona la tecla RET, que está en esta situación está asociado a help-follow, y ser tomado directamente a las fuente, en el mismo camino que M-. (find-tag). La definición para describe-function ilustra como personalizar las expresiones interactive sin usar los códigos de caracter estándar y eso muestra como crear un búffer temporal. (La función indent-to es escrita en C en vez de Emacs Lisp; eso es una función `contruida'. help-follow toma su fuente como find-tag, cuando se configura apropiadamente.) Se puede mirar en las fuentes de la función usando find-tag, que está asociado a M-.. Finalmente, se puede encontrar que el Manual de Referencia tiene que decir visitando el manual en Info, y escribiendo i (Info-index) y el nombre de la función, o buscando la función en el índice a una copia impresa del manual. Similarmente, se puede encontrar que significa por insert-and-inherit. Otros ficheros fuente interesantes incluyen ‘paragraphs.el’, ‘loaddefs.el’ y ‘loadup.el’. El fichero ‘paragraphs.el’ incluye ordenar, funciones fácilmente comprendidas tan bien como las largas. El fichero ‘loaddefs.el’ contiene muchos autoloads estándar y muchos mapas de teclado. Nunca se ha buscado en todo; solo en las partes. ‘loadup.el’ es el fichero que carga las partes estándar de Emacs; eso cuenta un gran trato acerca de cómo Emacs está construido. (Véase (elisp)Construyendo Emacs sección `Construyendo Emacs' en El Manual de Referencia GNU Emacs Lisp, para más acerca de construcción.) Como dije, se han aprendido algunas cosas; sin embargo, y de manera muy importante, se han tocado fuertes aspectos de la programación; no se ha dicho nada acerca de como ordenar la información, excepto para usar la función predefinida sort; no se ha dicho nada acerca de cómo almacenar la información, excepto para usar variables y listas; no se ha dicho nada acerca de como escribir programas que escriben programas. Esto son asuntos para otro tipo diferente de libro, un diferente tipo de aprendizaje. Lo que has hecho es aprender lo suficiente para mucho trabajo práctico con GNU Emacs. Lo que has hecho es comenzado. Este es el fin de un principio. ’





[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




A. La Función the-the






Algunas veces cuando se escribe texto, se duplican palabras --- como
con ``tu tu'' cerca del principio de esta frase. Se encuentra que lo
más frecuente, es duplicar ``el''; aquí, se llama a la
función para detectar las palabras duplicadas, the-the.



Como primer paso, se podría usar las siguientes
expresiones regulares para buscar duplicados:



 
\\(\\w+[ \t\n]+\\)\\1




Este regexp asocia una o más caracteres que constituyen palabras
seguidas por uno o más espacios, tabuladores, o nuevas
líneas. Sin embargo, eso no detecta palabras duplicadas
en diferentes líneas, desde la finalización de la
primera palabra, el fin de la línea, es diferente desde
el fin de la segunda palabra, un espacio. (Para más información
acerca de expresiones regulares, mira @ref{Busca Regexp, , B@'usquedas
de Expresiones Regulares}, tan bien como (emacs)Regexps sección `Sintaxis de Expresiones Regulares' en El Manual de GNU Emacs, y
(elisp)Expresiones Regulares sección `Expresiones Regulares' en El Manual de Referencia GNU Emacs Lisp.)



Se podría intentar buscar caracteres de palabras
duplicadas pero que no trabajando desde que el patrón detecta dobles
tales como las dos ocurrencias de `th' en `with the'.



Otro posible regexp busca para caracteres constituyentes de palabras
seguidos por caracteres de no palabras constituyente,
reduplicados. Aquí, ‘\\w+’ asocia a una o más
caracteres de palabras constituyente y ‘\\W*’ asocia cero o
más caracteres que no constituyen palabras.



 
\\(\\(\\w+\\)\\W*\\)\\1




De nuevo, no útil.



Aquí está el patrón que uso. No es perfecto, pero
suficientemente bueno. ‘\\b’ asocia la cadena
vacía provista al principio o fin de una palabra;
‘[^@ \n\t]+’ asocia una o más ocurrencias de qué
caracteres que no son un @-signo, espacio, nueva
línea, o tabulador.



 
\\b\\([^@ \n\t]+\\)[ \n\t]+\\1\\b




Uno puede escribir expresiones más complicada, pero se encuentra que
esta expresión es suficientemente buena, así yo lo uso.



Aquí la función the-the, como se incluye en mi
fichero ‘.emacs’, a lo largo de un atajo global manejable:



 
(defun the-the ()
  "Busca hacia adelante para una palabra duplicada."
  (interactive)
  (message "Buscando palabras duplicadas ...")
  (push-mark)

  ;; Este regexp no es perfecto
  ;; pero es limpiamente bueno a pesar de todo:
  (if (re-search-forward
       "\\b\\([^@ \n\t]+\\)[ \n\t]+\\1\\b" nil 'move)
      (message "Palabra encontrada duplicada.")
    (message "Fin de búffer")))

;; Asocia `the-the' a  C-c \
(global-set-key "\C-c\\" 'the-the)






Aquí está el test de texto:



 
uno dos tres cuatro cinco
cinco seis siete



Se puede sustituir las otras expresiones regulares mostradas debajo en
la definición de función y prueba cada uno de ellos en esta lista.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




B. Manejando el Anillo de la Muerte






El anillo de la muerte es una lista que es transformada dentro de un
anillo que trabaja con la función current-kill. Los comandos
yank y yank-pop usan la función current-kill.



Este apéndice describe la función current-kill tan bien
como ambos comandos yank y yank-pop, pero primero,
considera los trabajo del kill ring. 





Qué hace el Anillo de la Muerte  



B.1 La Función current-kill  



B.2 pegar                      Copiar una copia de un elemento clipeado.



B.3 yank-pop                   Insertar elemento apuntado.



B.4 El Fichero ‘ring.el’             











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Qué hace el Anillo de la Muerte



El anillo de la muerte kill ring tiene el tamaño máximo de
sesenta veces; este número es demasiado largo para una
explicación. En vez de eso, asígnalo a cuatro. Por
favor, evalúa lo siguiente:



 
(setq old-kill-ring-max kill-ring-max)
(setq kill-ring-max 4)




Entonces, por favor, copia cada línea del siguiente
ejemplo indentado dentro del anillo de la muerte kill ring. Se
puede cortar cada línea con C-k o marcarlo y
copiarlo con M-w.



(En un buffer de solo lectura, tal como el buffer ‘*info*’, el
comando kill, C-k (kill-line), no eliminará el texto,
solamente lo copia al anillo de la muerte kill ring. Sin
embargo, su máquina puede avisarte a ti. Alternativamente, para
silenciar, se puede copiar la región de cada línea con
el comando M-w (kill-ring-save). Se debe marcar cada
línea para este comando por éxito, pero no importa en
final se posiciona el punto o marca.)



Por favor, invoca las llamadas en orden, así que los
cinco elementos intenten rellenar el anillo de la muerte kill ring.



 
primer algo de texto
segunda pieza de texto
tercera línea
cuarta línea de texto
quinto bit de texto



Entonces encuentra el valor de kill-ring evaluando



 
kill-ring




Eso es:



 
("quinto bit de texto" "cuarta línea de texto"
"tercera línea" "segunda pieza de texto")



El primer elemento, ‘primero algo de texto’, fué borrado.



Para devolver el viejo valor para el tamaño del kill ring, evalúa:



 
(setq kill-ring-max old-kill-ring-max)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




B.1 La Función current-kill




La función current-kill cambia el elemento en el anillo de la
muerte kill ring para el que kill-ring-yank-pointer
apunta. (También, la función kill-new asigna
kill-ring-yank-pointer para apuntar al último elemento del
anillo de la muerte kill ring. La función kill-new es
usada directamente o indirectamente por kill-append,
copy-region-as-kill, kill-ring-save, kill-line, y
kill-region.)





El código current-kill  



current-kill en Outline    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




El código current-kill




La función current-kill es usada por yank y por
yank-pop. Aquí está el código para
current-kill:



 
(defun current-kill (n &optional do-not-move)
  "Rota el punto de pegue por N lugares, y entonces devuelve que
  corte.
Si N es cero, `interprogram-paste-function' está asignado, y lo 
llama devolviendo una cadena, entonces esta cadena está añadida
al frente del anillo de la muerte kill ring y devuelve como 
el último corte.
Si el argumento opcional DO-NOT-MOVE es no nulo, entonces no muevas el
punto de pegue; solo devuelve el Nth corte hacia adelante.
   (let ((interprogram-paste (and (= n 0)
                                  interprogram-paste-function
                                  (funcall interprogram-paste-function)))))
    (if interprogram-paste
        (progn
          ;; Deshabilita el programa que corte la función cuando se
          ;; añade el nuevo texto al anillo de la muerte kill ring,
          ;; así Emacs no intenta poseer la selección
          ;; con idéntico texto.
          (let ((interprogram-cut-function nil))
            (kill-new interprogram-paste))
          interprogram-paste)

      (or kill-ring (error "Kill ring is empty"))
      (let ((ARGth-kill-element
             (nthcdr (mod (- n (length kill-ring-yank-pointer))
                          (length kill-ring))
                     kill-ring)))
        (or do-not-move
            (setq kill-ring-yank-pointer ARGth-kill-element))
        (car ARGth-kill-element)))))




Recuerda también que la función kill-new asigna
kill-ring-yank-pointer al último elemento del anillo de la
muerte kill ring, que significa que todas las funciones que lo
llaman y asigna el valor de manera indirecta: kill-append,
copy-region-as-kill, kill-ring-save, kill-line y
kill-region. 



Aquí está la línea en kill-new,
que es explicado en la La función kill-new.



 
(setq kill-ring-yank-pointer kill-ring)









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




current-kill en Outline



La función current-kill parece compleja, pero usual, eso
puede ser comprendido tomándolo aparte pieza por pieza. Primero
míralo en la forma esquelética:



 
(defun current-kill (n &optional do-not-move)
  "Rota el punto a pegar por N lugares, y entonces devuelve el texto cortado."
  (let varlist
    body…)




Este función toma dos argumentos, uno que es opcional. Esto tiene
una cadena de documentación. Eso no es interactivo.





El cuerpo de current-kill  



Disgresión acerca de la palabra ‘error’    Cómo confundir humanos, pero no 
                                          ordenadores.



Determinando el Elemento    











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




El cuerpo de current-kill



El cuerpo de la definición de función es una expresión
let, que por sí mismo tiene un cuerpo tan bien
como una varlist.



La expresión let declara una variable que será solo usable
con las asociaciones de esta función. Esta variable es llamada
interprogram-paste y está copiando a otro programa. No está
copiando con esta instancia de GNU Emacs. La mayoría de
los sistemas de ventanas proveen una facilidad para pegar el
interprograma. Tristemente, esta facilidad normalmente provee solo el
último elemento. La mayoría de los sistemas de
ventanas no han adoptados un anillo de muchas posibilidades, incluso
aunque Emacs ha provisto eso por décadas.



La expresión if tiene dos parte, una si existe
interprogram-paste y una si no.



Permítenos considerar el `si no' o la parte else de la
función current-kill. (La parte then usa la función
kill-new, que ya hemos descrito. Véase la sección  La función kill-new.)



 
(or kill-ring (error "El Kill ring está vacío"))
(let ((ARGth-kill-element
       (nthcdr (mod (- n (length kill-ring-yank-pointer))
                    (length kill-ring))
               kill-ring)))
  (or do-not-move
      (setq kill-ring-yank-pointer ARGth-kill-element))
  (car ARGth-kill-element))




El código primero chequea si el kill ring anillo de la muerte
tiene contenido; de otro modo señala un error.



Note que la expresión or es muy similar para testear el
tamaño con un if:





 
(if (zerop (length kill-ring))          ; if-part
    (error "Anillo de la muerte vacío"))       ; then-part
  ;; No else-part




Si no hay nada en el kill ring anillo de la muerte, su tamaño
debe ser cero y un mensaje de error se envi' al usuario: ‘El
kill ring está vacío’. La función
current-kill usa una expresión or que es simple. Pero
una expresión if recuerda que va.



La expresión if usa la función zerop que devuelve
cierto si el valor que se chequea es cero. Cuando zerop chequea
cierto, la parte then del if se evalúa. La parte then es una
lista empezando con la función error, que es una función
que es similar para la función message (véase (además para imprimir un mensaje)message sección `La Función message en la imprime un mensaje de una línea en el área echo. Sin embargo' en error también para la evaluación de la función que es embebido. Esto significa que el resto de la función no será evaluado si el tamaño del anillo de la muerte kill ring es cero. Entonces la función current-kill selecciona el elemento a devolver. La selección depende del número de lugares que current-kill rota y donde kill-ring-yank-pointer apunta. Lo siguiente, si el argumento do-not-move opcional es verdadero o el actual valor de kill-ring-yank-pointer es establecido a punto a la lista. Finalmente, otra expresión devuelve el primer elemento de la lista incluso si el argumento do-not-move es verdadero.





[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Disgresión acerca de la palabra ‘error’



En mi opinión, eso es ligeramente erróneo, al menos para humanos,
para usar el término `error' como el nombre de la función
error. Un término mejor sería
`cancelar'. Estrictamente hablando, de acuerdo, no se puede apuntar,
mucho menos rotar un puntero a una lista que no tiene tamaño,
así desde el punto de vista del ordenador, la palabra
`error' es correcto. Pero un humanos espera intentar algo, si solo se
encuentra si el anillo de la muerte está lleno o
vacío. Esto es un acto de exploración.



Desde el punto de vista humano, el acto de exploración y
descubrimiento no es necesariamente un error, y por esta razón no
sería etiquetado como uno, incluso las vocales de un
ordenador. Como es, el código en Emacs implica que un humanos quien
está actuando virtuosamente, explorando su entorno, está teniendo
un error. Esto está mal. Incluso aunque el ordenador toma los mismos
pasos como cuando hay `error', un término tal como `cancelar'
tendría una clara connotación.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Determinando el Elemento



Entre otras acciones, la else-part de la expresión if asigna
el valor de kill-ring-yank-pointer a ARGth-kill-element
cuando el kill ring anillo de la muerte tiene alguna cosa
dentro y el valor de do-not-move es nil.



El código se parece a esto:



 
(nthcdr (mod (- n (length kill-ring-yank-pointer))
             (length kill-ring))
        kill-ring)))




Esto necesita algún examen. A menos que no se suponga mover el
puntero, la función current-kill cambia donde
kill-ring-yank-pointer apunta. Esto es lo que el (setq
kill-ring-yank-pointer ARGth-kill-element) expresión
hace. También, claramente, ARGth-kill-element está siendo
asignado a ser igual para algún CDR del anillo de la muerte
kill ring, usando la función nthcdr que está
descrita en una sección temprana. (Véase la sección  copy-region-as-kill.)
¿Cómo se hace?



Como se ha visto antes (véase la sección nthcdr), la función nthcdr
funciona repetidamente tomando el CDR de una lista --- eso toma
el CDR del CDR del CDR …



Las siguientes dos expresiones producen el mismo resultado:



 
(setq kill-ring-yank-pointer (cdr kill-ring))

(setq kill-ring-yank-pointer (nthcdr 1 kill-ring))




Sin embargo, la expresión nthcdr es más complicada. Usa la
función mod para determinar que CDR para seleccionar.



(Se recordará buscar funciones propias primero, en vez de esto,
tendremos que ir dentro del mod.)



La función mod devuelve el valor de su primer argumento
modulo el segundo; que es decir, eso devuelve el resto después de
dividir el primer argumento por el segundo. El valor devulto tiene el
mismo signo que el segundo argumento.



De este modo,



 
(mod 12 4)
  ⇒ 0  ;; porque no hay recuerdo
(mod 13 4)
  ⇒ 1




En este caso, el primer argumento es con frecuencia pequeño que el
segundo. Que está bien.



 
(mod 0 4)
  ⇒ 0
(mod 1 4)
  ⇒ 1




Se puede adivinar que la función - hace. Eso es como +
pero sustrae en vez de añadir; la función - sustrae su
segundo argumento desde el primero. También, ya se sabe que la
función length hace (véase la sección Encuentra el tamaño de una Lista: length). Eso devuelve el
tamaño de una lista.



Y n es el nombre del argumento requerido a la función
current-kill.



Así cuando el primer argumento a nthcdr es cero,
la expresión nthcdr devuelve la lista entera, como se puede
ver evaluando lo siguiente:



 
;; kill-ring-yank-pointer and kill-ring tener un tamaño de cuatro
;; and (mod (- 0 4) 4) ⇒ 0
(nthcdr (mod (- 0 4) 4)
        '("cuarta línea de texto"
          "tercera línea"
          "segunda pieza de texto"
          "primero algo de texto"))




Cuando el primer argumento a la función current-kill es uno,
la expresión nthcdr devuelve la lista sin su primer elemento.



 
(nthcdr (mod (- 1 4) 4)
        '("cuarta línea de texto"
          "tercera línea"
          "segunda pieza de texto"
          "primero algo de texto"))






Incidentalmente, tanto kill-ring y
kill-ring-yank-pointer son variables globales. Esto
significa que cualquier expresión en Emacs Lisp puede acceder a
ellas. Ellas no son como las variables locales asignadas por
let o como los símbolos en una lista de
argumentos. Las variables locales pueden solo ser accedidas con el
let que los define o la función que los especifica en una
lista de argumentos (y con expresiones llamadas por ellos).









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




B.2 pegar




Después de aprender acerca de current-kill, el código para
la función yank es casi fácil.



La función yank no usa variable kill-ring-yank-pointer
directamente. Eso llama a insert-for-yank que llama a
current-kill que asigna la variable kill-ring-yank-pointer.



El código se parece a esto:



 
(defun yank (&optional arg)
  "Reinserta (\"pega\") el último logro del texto cortado.
Más precisamente, reinserta el texto cortado más recientemente. 
Pon el punto al final, y asigna la marca al principio.
Solo con \[universal-argument] como argumento, lo mismo pero pon el 
punto al principio (y marca al final). Con el argumento N, reinserta 
el N más recientemente cortado."
Cuando este comando inserta texto cortado dentro del búffer, eso
honra a `yank-excluded-properties' y `yank-handler' como se describe
la cadena de documentación para `insert-for-yank-1', que se ve. Ver también el comando \\[yank-pop]."

  (interactive "*P")
  (setq yank-window-start (window-start))
  ;; Si no tenemos todo el camino a través, crea last-command que
  ;; indique esto para el siguiente comando.
  (setq this-command t)
  (push-mark (point))

  (insert-for-yank (current-kill (cond
                                  ((listp arg) 0)
                                  ((eq arg '-) -2)
                                  (t (1- arg)))))
  (if (consp arg)
      ;; Esto es como like exchange-point-and-mark,
      ;;     pero no activa la marca.
      ;; Es limpio evitar la activación, incluso aunque el comando
      ;; loop would deactivaría la marca porque se
      ;; insertara el texto.
      (goto-char (prog1 (mark t)
                   (set-marker (mark-marker) (point) (current-buffer)))))

  ;; Si tenemos todo el camino, haz que this-command lo indique.
  (if (eq this-command t)
      (setq this-command 'yank))
  nil)




La expresión clave es insert-for-yank, que inserta la cadena
devuelta por current-kill, pero elimina algo de propiedades de
texto desde eso.



Sin embargo, antes de tener esta expresión, la función asigna el
valor de yank-window-start a la posición devueltaa por la
expresión (window-start), la posición a el que muestra lo
que actualmente empieza. La función yank también asigna
this-command y empuja la marca.



Después de pegar el elemento apropiado, si el argumento opcional es
un CONS en vez de un número o nada, pone el punto al principio
del texto pegado y márcalo al final.



(La función prog1 es como progn pero devuelve el valor
de su primer argumento en vez del valor de su último argumento. Su
primer argumento fuerza devolver la marca del búffer como un
entero. Se puede ver la documentación para estas funciones
emplazando el punto a través de ellos en este búffer y entonce
escribiendo C-h f (describe-function) seguido por un
RET; por defecto es la función.)



La última parte de la función cuenta que hacer cuando eso sucede.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




B.3 yank-pop




Después de comprender yank y current-kill, se conoce
como enfocar la función yank-pop. Dejando fuera la
documentación para guardar el espacio, eso se parece a esto:



 
(defun yank-pop (&optional arg)
  "…"
  (interactive "*p")
  (if (not (eq last-command 'yank))
      (error "El comando previo no fué un corte"))

  (setq this-command 'yank)
  (unless arg (setq arg 1))
  (let ((inhibit-read-only t)
        (before (< (point) (mark t))))

    (if before
        (funcall (or yank-undo-function 'delete-region) (point) (mark t))
      (funcall (or yank-undo-function 'delete-region) (mark t) (point)))
    (setq yank-undo-function nil)

    (set-marker (mark-marker) (point) (current-buffer))
    (insert-for-yank (current-kill arg))
    ;; Asigna la ventana empieza donde fué en el comando yank,
    ;; si es posible
    (set-window-start (selected-window) yank-window-start t)

    (if before
        ;; Esto es como exchange-point-and-mark,
        ;; pero no activa la marca.
        ;; Es limpio evitar la activación, incluso aunque el comando
        ;; desactivase la marca porque se insertara el texto.
        (goto-char (prog1 (mark t)
                     (set-marker (mark-marker)
                                 (point)
                                 (current-buffer))))))
  nil)




La función es interactive con una pequeña ‘p’
así el argumento prefijo es procesado y pasado a la
función. El comando puede solo ser usado después del yank previo;
de otro modo un mensaje de error es enviado. Este chequeo usa la
variable last-command que es asignado por yank y es
discutido de algún modo. (Véase la sección  copy-region-as-kill.)



La cláusula let asigna la variable before a cierto o
falso dependiendo de si el punto está antes o después de la marca
y entonce la región entre punto y marca se borra. Esta es la
región que fué insertada por el yank previo y eso es este texto
que será reemplazado.



funcall llama su primer argumento como una función, pasando
los argumentos que permanecen a eso. El primer argumento es el que la
expresión or devuelve. Los dos argumentos que permanecen son
las posiciones de puntoy marca asignadas por el comando precedente
yank. 



Hay más, pero esta es la parte más dura.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




B.4 El Fichero ‘ring.el’




De manera interesante, GNU Emacs posee un fichero llamado
‘ring.el’ que provee muchas de las funcionalidades que ahora se
discuten. Pero las funciones tales como kill-ring-yank-pointer
no usa esta librería, posiblemente porque fueron
escritas pronto.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C. Un Grafo con Ejes Etiquetados



Los ejes impresos ayudan a comprender un grafo. Para crear escalas. En
un capítulo anterior (@pxref{Leyendo un Graf, , Leyendo
un Grafo}), se escribió el código para imprimir el cuerpo de un
grafo. Aquí se escribe el código para imprimir y
etiquetando ejes horizontales y verticales, a lo largo con el cuerpo
en sí.





Grafo de Ejemplo Etiquetado  



C.1 La Varlist print-graph        expresión let en print-graph.



C.2 La Función print-Y-axis               Imprimir una etiqueta para los ejes verticales.



C.3 La Función print-X-axis               Imprimir una etiqueta horizontal.



C.4 Imprimiendo el Grafo Completo      La función para imprimir un grafo completo.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Grafo de Ejemplo Etiquetado



Desde que las inserciones rellenan un buffer a la derecha y debajo del
punto, el nuevo grafo que imprime la función primero
imprimiría el eje vertical Y, entonces del cuerpo del
grafo, y finalmente el eje horizontal X. Esta secuencia nos deposita
para nosotros los contenidos de la función:



    

  1. 
Configurar código.


  2. 
Imprime el eje Y.


  3. 
Imprime el cuerpo del grafo.


  4. 
Imprime el eje X.




Aquí hay un ejemplo de cuanto un grafo finalizado se ve:



 
    10 -
                  *
                  *  *
                  *  **
                  *  ***
     5 -      *   *******
            * *** *******
            *************
          ***************
     1 - ****************
         |   |    |    |
         1   5   10   15




En este grafo, ambos ejes vertical y horizontal son etiquetados con
números. Sin embargok, en algunos grafos, el eje horizontal es
tiempo y sería mejor etiquetado con meses, como esto:



 
     5 -      *
            * ** *
            *******
          ********** **
     1 - **************
         |    ^      |
       Enero Junio Enero




Dentro, con un pequeño pensamiento, se puede fácilmente viene con
una variedad de vertical y horizontal etiquetando esquemas. Nuestra
tarea llega a ser complicada. Pero las complicaciones generan
confusión. En vez de permitir esto, es mejor elegir un simple
esquema de etiquetado para nuestro primer esfuerzo, y modificar o
reemplazarlo después.



Estas consideraciones sugieren el siguiente outline para la función
print-graph:



 
(defun print-graph (numbers-list)
  "documentation…"
  (let ((height  …
        …))

    (print-Y-axis height … )
    (graph-body-print numbers-list)
    (print-X-axis … )))




Nosotros podemos trabajar en cada parte de la definición de función
print-graph en turno.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.1 La Varlist print-graph




Escribiendo la función print-graph, la primera tarea es
escribir la varlist en la expresión let. (Nosotros dejaremos
por ahora cualquier pensamiento acerca de hacer la función
interactive o acerca de los contenidos de su cadena de documentación.)



La varlist asignaría varios valores. Claramente, la
etiqueta superior del eje vertical debe ser al menos la altura del
grafo, que significa que debe obtener esta información
aquí. Note que la función print-graph-body
también requiere esta información. No hay razón para calcular la
altura del grafo en dos lugares diferentes, así
cambiaría print-graph-body desde el camino que
definimos pronto para tomar ventaja del cálculo.



De manera similar, tanto la función para imprimir la etiqueta del
eje X y la función print-graph-body necesita aprender el
valor del ancho de cada símbolo. Se puede desarrollar el
cálculo aquí y cambiar la definición para
print-graph-body desde el camino que se definió en el
capítulo previo.



El tamaño de la etiqueta para el eje horizontal debe ser al menos
tan largo como el grafo. Sin embargo, esta información es usada solo
en la función que imprime el eje horizontal, así no
necesita ser calculado aquí.



Estos pensamientos nos lideran directamente a la siguiente forma para
la varlist en el let para print-graph:



 
(let ((height (apply 'max numbers-list)) ; Primera versión.
      (symbol-width (length graph-blank)))




As se verá, esta expresión no es bastante correcta.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.2 La Función print-Y-axis







El trabajo de la función print-Y-axi es imprimir una etiqueta
para el eje vertical que se parece a esto:



 
    10 -




     5 -



     1 -




La función sería pasado el alto del grafo, y entonces
construiría e inserta los números apropiados y marcas.





La Función print-Y-axis en Detalle  



¿Qué altura se debería etiquetar?         ¿Qué altura para el eje Y?



C.2.1 Viaje Lateral: Computa un Recuerdo    Cómo computar el recuerdo de una división.



C.2.2 Construye un Elemento del Eje Y         Construir una línea para el eje 
                               Y.



C.2.3 Crea un Eje de la Columna Y              Generar una lista de etiquetas del eje Y.



C.2.4 La Versión No Demasiado Final de print-Y-axis    Una versión no muy final.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




La Función print-Y-axis en Detalle



Es suficiéntemente fácil para ver y figura que la etiqueta del eje
Y miraría así; pero decir en palabras, y
entonces escribir una definición de función para hacer el trabajo
es otra materia. Esto no es bastante verdad decir que se quiere un
número y un tic cada cinco líneas: solo hay tres
líneas entre el ‘1’ y el ‘5’
(líneas 2, 3 y 4), pero cuatro líneas
entre fel ‘5’ y el ‘10’ (líneas 6, 7, 8 y
9). Esto es mejor decir que se quiere un número y un tic en la
quinta línea desde abajo a cada línea que
un múltiplo de cinco.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




¿Qué altura se debería etiquetar?



La siguiente cuestión es a que altura se
etiquetaría. Supón que la máxima altura de la columna
mayor del grafo es siete. La etiqueta superior en el eje Y
sería ‘5 -’, ¿y el grafo se pegaría
debajo de la etiqueta?, ¿o la etiqueta superior sería
‘7 -’, y marcar la vertical del grafo? ¿o sería la
etiqueta superior 10 -, que es múltiplo de cinco, y es
superior que el valor más alto del grafo?



La última forma es preferida. La mayoría de los grafos
con rectángulos cuyos lados son un número integral de pasos a lo
largo --- 5, 10, 15, y así para un paso a distancia de
cinco. Pero tan pronto se decide usar un paso alto para el eje
vertical, se descubre que la expresión simple en la varlist para la
altura de la computación es errónea. La expresión es
(apply 'max numbers-list). Esto devuelve la altura precisa, no
la altura máxima más lo que es necesario para redondear el
múltiplo de cinco. Una expresión más compleja es requerida.



Como es normal es casos como este, un problema complejo llega a ser
simple si eso está dividido en varios problemas pequeños.



Primero, considera el caso cuando el valor superior del grafo es un
múltiplo integral de cinco --- cuando eso es 5, 10, 15, o algún
múltiplo de cinco. Se puede usar este valor como la altura del eje Y.



Un camino simple y limpio para determinar si un número es múltiplo
de cinco se divide por cinco y mira si la división resulta en un
recuerdo. Si no hay recuerda, el número es un múltiplo de
cinco. De este modo, siete dividido tiene un recuerdo de dos, y siete
no es un integral múltiplo de cinco. Pon en un lenguaje ligeramente
diferente, más reminiscente de cinco va dentro de diez dos veces,
sin recuerdo: diez es un múltiplo integral de cinco.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.2.1 Viaje Lateral: Computa un Recuerdo





En Lisp, la función para la computación un recuerdo es
%. La función devuelve el recuerdo de su primer argumento
dividido por su segundo argumento. Como ocurre, % es una
función en Emacs Lisp que no se puede descubre usando
apropos: no se puede encontrar nada si se escribe M-x
apropos <RET> recuerda <RET>. El único camino para aprender
la existencia de % es leer acerca de eso en un libro tal como
esto en las fuentes de Emacs Lisp.



Se puede probar la función % evaluando las siguientes dos
expresiones:



 
(% 7 5)

(% 10 5)




La primera expresión devuelve 2 y la segunda expresión devuelve 0.



Para chequear si el valor devuelto es cero o algún otro número, se
puede usar la función zerop. Esta función devuelve t
si su argumento que debe ser un número, es cero.



 
(zerop (% 7 5))
     ⇒ nil

(zerop (% 10 5))
     ⇒ t




De este modo, la siguiente expresión devolverá t si la
altura del grafo es divisible por cinco:



 
(zerop (% height 5))




(El valor de height, de acuerdo, puede ser encontrado desde
(apply 'max numbers-list).)



Por otro lado, si el valor de height no es un múltiplo de
cinco, nosotros queremos resetear el valor al siguiente alto
múltiplo de cinco. Esto es la aritmética sencilla usando funciones
con las que están ya familiarizados. Primero, se divide el valor de
height por cinco para determinar cuantas veces cinco va dentro
del número. De este modo, cinco va dentro doce veces. Si se añade
uno a este cociente y se multiplica por cinco, obtendremos el valor
del siguiente múltiplo de cinco que es más largo que el
alto. Cinco va dentro de doce dos veces. Añade uno a dos, y
multiplica por cinco; los resultados son quince, que es el siguiente
múltiplo de cinco que es mayor que doce. La expresión Lisp para
esto es:



 
(* (1+ (/ height 5)) 5)




Por ejemplo, si tu evalúas lo siguiente, el resultado es 15:



 
(* (1+ (/ 12 5)) 5)




Todo a través de esta discusión, hemos estado usando `cinco' como
el valor paraa las etiquetas espaciadas en el eje Y; pero se puede
querer usar algún otro valor. Generalmente,
reemplazaría `cinco' con una variable a la que poder
asignar un valor. El mejor nombre que puedo pensar para esta variable
es Y-axis-label-spacing.



Usando este término, y una expresión if, se produce lo siguiente:



 
(if (zerop (% height Y-axis-label-spacing))
    height
  ;; else
  (* (1+ (/ height Y-axis-label-spacing))
     Y-axis-label-spacing))




Esta expresión devuelve el valor de height en
sí si la altura es incluso un múltiplo del valor del
Y-axis-label-spacing o lo demás computa y devuelve un valor
de height que es igual a la siguiente alto múltiplo del
valor del Y-axis-label-spacing.



Se puede ahora incluir esta expresión en la expresión let
de la función print-graph (después de la primera
configuración del valor de Y-axis-label-spacing):




 
(defvar Y-axis-label-spacing 5
  "Número de líneas desde una etiqueta del eje Y al siguiente.")

…
(let* ((height (apply 'max numbers-list))
       (height-of-top-line
        (if (zerop (% height Y-axis-label-spacing))
            height

          ;; else
          (* (1+ (/ height Y-axis-label-spacing))
             Y-axis-label-spacing)))
       (symbol-width (length graph-blank))))
…




(Nota el uso de la función let*: el valor inicial de la
altura es computado una vez por la expresión (apply 'max
numbers-list) y entonces el valor resultando de height es
usado para computar su valor final. Véase la sección  La expresión let*, para más acerca de let*.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.2.2 Construye un Elemento del Eje Y



Cuando se imprima el eje vertical, se quieren insertar cadenas tales
como ‘5 -’ y ‘10 - ’ cada cinco
líneas. Más allá, se quieren los números agitados
para alinear, así pocos números deben ser acuñados
con espacios de guía. Si alguna de las cadenas usan dos
dígitos, las cadenas con un simple dígito
deben incluir una guía en blanco antes del número.




Para figurarse el tamaño del número, la función length
está usado. Pero la función length funciona solo con una
cadena, no con un número. Así el número tiene que
ser convertido desde un número a una cadena. Esto es hecho con la
función number-to-string. Por ejemplo,



 
(length (number-to-string 35))
     ⇒ 2

(length (number-to-string 100))
     ⇒ 3




(number-to-string está también llamado
int-to-string; se verá este nombre alternativo en varias fuentes.)



Además, en cada etiqueta, cada número es seguido por una cadena
tal como ‘ - ’, que se llamará el marcador
Y-axis-tic. Esta variable está definidad con defvar:




 
(defvar Y-axis-tic " - "
   "La Cadena que sigue el número en una etiqueta del eje Y.")




El tamaño de la etiqueta Y es la suma del tamaño del eje Y y el
tamaño del número del alto del grafo.



 
(length (concat (number-to-string height) Y-axis-tic)))




Este valor será calculado por la función print-graph en su
varlist como full-Y-label-width y se pasa dentro. (Note que no
se pensón en incluir esto en el varlist cuando se propuso.)



Para crear un eje vertical completo, una marca de tic es concatenada
con un número; y los dos juntos pueden ser precedidos por uno o
más espacios dependiendo de cómo de largo es el número. La
etiqueta consiste de tres partes: los espacios que se lideran
(opcional), el número, y la marca tic. La función es pasada al
valor del número para la fila específica, y el valor
del ancho de la línea de arriba, que es calculada (solo
una vez) por print-graph.



 
(defun Y-axis-element (number full-Y-label-width)
  "Construye una etiqueta NUMERADA
Un elemento numerado se parece a esto ` 5 - ', 
y est'a tan acuñado como se necesita así todo se
  alinea con el elemento para el número más largo."

  (let* ((leading-spaces
         (- full-Y-label-width
            (length
             (concat (number-to-string number)
                     Y-axis-tic)))))

    (concat
     (make-string leading-spaces ? )
     (number-to-string number)
     Y-axis-tic)))




La función Y-axis-element concatena junto los espacios que se
lideran si cualquiera; el número, como una cadena; y la marca tic.



Para imaginarnos cuantos espacios guía la etiqueta
necesita, la función sustrae el tamaño de la etiqueta --- el
tamaño del número más el tamaño de la marca tic --- desde el
ancho de la etiqueta deseada.




Los espacios en blanco son insertados usando la función
make-string. Esta función tiene dos argumentos: lo primero
cuenta como de larga será y el segundo es un símbolo
para el caracter a insertar, en un formato espcial. El formato es una
marca de pregunta seguida por un espacio en blanco, como este,
‘?’. Véase (elisp)Tipo de Caracter sección `Tipo de Caracter' en El Manual de Referencia Emacs Lisp, para una descripción de la sintaxis para
caracteres. (De acuerdo, se podría quere reemplazar el
espacio en blanco por algún otro caracter …. Tu sabes qué hacer.)



La función number-to-string es usada en la expresión de
concatenación, para convertir el número a una cadena que es
concatenada con los espacios que se lideran y la marca de tic.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.2.3 Crea un Eje de la Columna Y



Las funciones precedentes proporcionan todas las herramientas
necesarias para construir una función que genera una lista de
cadenas enumeradas y en blanco para inserta como la etiqueta para el
eje vertical:




 
(defun Y-axis-column (height width-of-label)
  "Construye la lista de ejes Y etiquetadas y cadenas en blanco.
Para height la altura de la línea de debajo y width-of-label."
  (let (Y-axis)

    (while (> height 1)
      (if (zerop (% height Y-axis-label-spacing))
          ;; Insertar etiqueta.
          (setq Y-axis
                (cons
                 (Y-axis-element height width-of-label)
                 Y-axis))

        ;; Else, insertar blancos.
        (setq Y-axis
              (cons
               (make-string width-of-label ? )
               Y-axis)))
      (setq height (1- height)))
    ;; Insertar la línea base.
    (setq Y-axis
          (cons (Y-axis-element 1 width-of-label) Y-axis))
    (nreverse Y-axis)))




En esta función, nosotros empezamos con el valor de height y
repetitivamente sustrae uno desde su valor. Después de cada
sustración, se chequea para ver si el valor es una integral
múltiple del Y-axis-label-spacing. Si eso es, se construye
una etiqueta numerada usando la función Y-axis-element; si
no, se construye una etiqueta blanca usando la función
make-string. La línea base consiste del número
uno seguido por una marca tic.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.2.4 La Versión No Demasiado Final de print-Y-axis



La lista construida por la función Y-axis-column está pasada
a la función print-Y-axis, que inserta la lista como una columna.




 
(defun print-Y-axis (height full-Y-label-width)
  "Inserta el eje Y usando HEIGHT y FULL-Y-LABEL-WIDTH.
La altura debe ser la máxima altura del grafo.
El ancho completo es el ancho del mayor elemento de la
etiqueta"
;; El valor del alto y full-Y-label-width
;; son pasadas por `print-graph'.

  (let ((start (point)))
    (insert-rectangle
     (Y-axis-column height full-Y-label-width))
    ;; Posiciona el punto listo para inserta el grafo.
    (goto-char start)
    ;; Mueve el punto hacia adelante por valor de full-Y-label-width
    (forward-char full-Y-label-width)))




El print-Y-axis usa la función insert-rectangle para
inserta el eje Y creado por la función
Y-axis-column. Además, eso emplaza el punto en la posición
correcta para imprimir el cuerpo del grafo.



Se puede chequear print-Y-axis:



    

  1. 
Instalar


     
    Y-axis-label-spacing
Y-axis-tic
Y-axis-element
Y-axis-column
print-Y-axis

    


  2. 
Copia la siguiente expresión:


     
    (print-Y-axis 12 5)

    


  3. 
Cambia al búffer ‘*scratch*’ y emplaza el cursor donde se
quiere el eje etiquetado para empezar. 


  4. 
Escribe M-: (eval-expression).


  5. 
Pega la expresión graph-body-print dentro del minibuffer con
C-y (yank).


  6. 
Presiona <RET> para evaluar la expresión




Emacs imprimirá etiquetas verticalmente, el primero siendo
‘10 - ’. (La función print-graph pasará el
valor de height-of-top-line, que en este caso finalizará en
15, por esto lo que se obtiene podría aparecer como un error.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.3 La Función print-X-axis







Las etiquetas del eje X son como las etiquetas del eje Y, excepto que
los ticks son un línea debajo de los
números. Etiquetas se parece como esto:



 
    |   |    |    |
    1   5   10   15




El primer tic está bajo la primera columna del grafo y está
precedido por varios espacios en blanco. Estos espacios proporcionan
la habitación en filas de debajo para las etiquetas del eje Y. El
segundo, tercer, cuarto, y subsiguientes ticks son todos espaciados
igualmente, de acuerdo al valor de X-axis-label-spacing.



La segunda fila del eje X consiste de números, precedidos por varios
espacios en blanco y también separado de acuerdo al valor de la
variable X-axis-label-spacing.



El valor de la variable X-axis-label-spacing
sería medido en unidades de symbol-width, desde
que se puede querer cambiar el ancho de los símbolos que
estás usando para imprimir el cuerpo del grafo sin cambiar los
caminos del grafo que está etiquetado.





Similaridades y diferencias      Mucho como print-Y-axis, pero no 
                               exactamente.



C.3.1 Eje X Marca Tic            Crear marcas de tic para los ejes horizontales.











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Similaridades y diferencias



La función print-X-axis está construida en más o menos
del mismo modo como el función print-Y-axis excepto que tiene
dos líneas: la línea de marcas tic y los
números. Nosotros escribiremos una función separado a imprimir
cada línea y entonces combinarlo con la función
print-X-axis.



Esto es un proceso de tres pasos:



    

  1. 
Escribe una función para imprimir el eje X marca tic,
print-X-axis-tic-line.


  2. 
Escribe una función imprime los números X,
print-X-axis-numbered-line.


  3. 
Escribe una función para imprimir ambas líneas, la
función print-X-axis, usando print-X-axis-tic-line y
print-X-axis-numbered-line.









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.3.1 Eje X Marca Tic



La primera función imprimiría las marcs de tic del eje
X. Se debe especificar las marcas en sí y su espacio:



 
(defvar X-axis-label-spacing
  (if (boundp 'graph-blank)
      (* 5 (length graph-blank)) 5)
  "Números de unidades desde un eje X al siguiente.")




(Note que el valor de graph-blank est'a asignaod por otro
defvar. El predicado boundp predicado chequea si ya ha
sido asignado; boundp devuelve nil si no lo tiene. Si
graph-blank fuera disociado y no usara esta construcción
condicional, en un GNU Emacs reciente, se introduciría
el depurador y mirará un mensaje de error diciendo ‘Debugger
entered--Lisp error: (void-variable graph-blank)’



Aquí está el defvar para X-axis-tic-symbol:



 
(defvar X-axis-tic-symbol "|"
  "Cadena para insertar para apuntar a una columna en el eje X.")




El objetivo es crear una línea que se parece a esto:



 
       |   |    |    |




El primer tic es indentado así que está bajo la
primera columna, que es indentado para proveer espacio para las
etiquetas del eje Y.



Un elemento tic consiste de espacios en blanco que extiende desde un
tic al siguiente más un símbolo tic. El número de
espacios en blanco son determinado por el ancho del
símbolo tic y el X-axis-label-spacing.



El código se parece a esto:



 
;;; X-axis-tic-element
…
(concat
 (make-string
  ;; Make a string of blanks.
  (-  (* symbol-width X-axis-label-spacing)
      (length X-axis-tic-symbol))
  ? )
 ;; Concatenate blanks with tic symbol.
 X-axis-tic-symbol)
…




Lo siguiente, determina cuantos espacios en blanco son necesarios para
indentar la primera marca tic a la primera del grafo. Esto usa el
valor de full-Y-label-width pasaba por la función
print-graph.



El código para crear X-axis-leading-spaces se parece a esto:



 
;; X-axis-leading-spaces
…
(make-string full-Y-label-width ? )
…




También necesita determinar el tamaño del eje horizontal, que es
el tamaño de la lista de números, y el número de ticks en el eje
horizontal:



 
;; X-length
…
(length numbers-list)

;; tic-width
…
(* symbol-width X-axis-label-spacing)

;; number-of-X-ticks
(if (zerop (% (X-length tic-width)))
    (/ (X-length tic-width))
  (1+ (/ (X-length tic-width))))




Todo esto lidera directamente a la función para imprimir el eje X:




 
(defun print-X-axis-tic-line
  (number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
  "Print ticks for X axis."
    (insert X-axis-leading-spaces)
    (insert X-axis-tic-symbol)  ; Under first column.

    ;; Inserta el segundo tic en la sustancia adecuada.
    (insert (concat
             (make-string
              (-  (* symbol-width X-axis-label-spacing)
                  ;; Inserta el espacio en blanco al segundo símbolo tic.
                  (* 2 (length X-axis-tic-symbol)))
              ? )
             X-axis-tic-symbol))

    ;; Inserta los ticks que permanecen.
    (while (> number-of-X-tics 1)
      (insert X-axis-tic-element)
      (setq number-of-X-tics (1- number-of-X-tics))))




La línea de números es igualmente simple:



Primero, creamos un elemento numerado con espacios en blanco antes de
cada número:




 
(defun X-axis-element (number)
  "Construya un elemento del eje X numerado."
  (let ((leading-spaces
         (-  (* symbol-width X-axis-label-spacing)
             (length (number-to-string number)))))
    (concat (make-string leading-spaces ? )
            (number-to-string number))))




Lo siguiente, se crea la función para imprimir la
línea numerada, empezando con el número ``1'' para la
primera columna:




 
(defun print-X-axis-numbered-line
  (number-of-X-tics X-axis-leading-spaces)
  "Imprime la líneas de números del eje X"
  (let ((number X-axis-label-spacing))
    (insert X-axis-leading-spaces)
    (insert "1")

    (insert (concat
             (make-string
              ;; Inserta espacios en blanco al siguiente número.
              (-  (* symbol-width X-axis-label-spacing) 2)
              ? )
             (number-to-string number)))

    ;; Insertar números.
    (setq number (+ number X-axis-label-spacing))
    (while (> number-of-X-tics 1)
      (insert (X-axis-element number))
      (setq number (+ number X-axis-label-spacing))
      (setq number-of-X-tics (1- number-of-X-tics)))))




Finalmente, se necesita escribir lo que print-X-axis que usa
print-X-axis-tic-line y print-X-axis-numbered-line.



La función debe determinar los valores locales de las variables
usadas por print-X-axis-tic-line y
print-X-axis-numbered-line, y entonces eso debe
llamarlas. También, debe imprimir el retorno de carro que separe las
dos líneas.



La función consiste de una varlist que especifica cinco variables
locales, y llama cada una de las dos líneas imprimiendo
funciones:




 
(defun print-X-axis (numbers-list)
  "Imprime el eje X etique al tamaño de NUMBERS-LIST."
  (let* ((leading-spaces
          (make-string full-Y-label-width ? ))

       ;; symbol-width se provee por graph-body-print
       (tic-width (* symbol-width X-axis-label-spacing))
       (X-length (length numbers-list))

       (X-tic
        (concat
         (make-string

          ;; Crea una cadena de espacios en blanco.
          (-  (* symbol-width X-axis-label-spacing)
              (length X-axis-tic-symbol))
          ? )

         ;; Concatena espacio en blanco con símobolos
         tic.
         X-axis-tic-symbol))

       (tic-number
        (if (zerop (% X-length tic-width))
            (/ X-length tic-width)
          (1+ (/ X-length tic-width)))))

    (print-X-axis-tic-line tic-number leading-spaces X-tic)
    (insert "\n")
    (print-X-axis-numbered-line tic-number leading-spaces)))




Se puede testear print-X-axis:



    

  1. 
Instala X-axis-tic-symbol, X-axis-label-spacing,
print-X-axis-tic-line, tanto como X-axis-element,
print-X-axis-numbered-line, y print-X-axis.


  2. 
Copia la siguiente expresión:


     
    (progn
 (let ((full-Y-label-width 5)
       (symbol-width 1))
   (print-X-axis
    '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))))

    


  3. 
Cambia al búffer ‘*scratch*’ y emplaza el cursor donde se
quiere el eje etiquetado para empezar. 


  4. 
Escribe M-: (eval-expression).


  5. 
Pega la expresión de test dentro del minibuffer con C-y
(yank).


  6. 
Presiona <RET> para evaluar la expresión




Emacs imprimirá el eje horizontal así





 
     |   |    |    |    |
     1   5   10   15   20









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4 Imprimiendo el Grafo Completo






Ahora estamos listos para imprimir el grafo completo.



La función para imprimir el grafo con las etiquetas apropiadas sigue
el esquema que creamos antes (véase la sección Un Grafo con Ejes Etiquetados), pero con adiciones.



Aquí está el esquema:



 
(defun print-graph (numbers-list)
  "documentation…"
  (let ((height  …
        …))

    (print-Y-axis height … )
    (graph-body-print numbers-list)
    (print-X-axis … )))






Cambios para la Versión Final         Unos pocos cambios



C.4.1 Testeando print-graph        Ejecutar un rápido test.



C.4.2 Creando Gráficas de Números de Palabras y Símbolos    Ejecutando el código final.



C.4.3 Una Expresión lambda: Anonimicidad Útil                     Cómo escribir una función anónima.



C.4.4 La Función mapcar                     Aplicar una función a elementos de una lista.



C.4.5 Otro Error … Más Insidioso                 Todavía otro error … más 
                               insidioso.



C.4.6 El Gráfico Impreso        ¡El grafo por sí 
                               mismo!











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Cambios para la Versión Final



La versión final es diferente desde que se planea en dos caminos:
primero, contiene los valores adicionales calculadas una vez que en la
varlist; segundo, eso trae una opción para específicar
las etiquetas se incrementa la fila. Esta última funcionalidad
cambia a ser esencial; de otro modo, un grafo puede tener más filas
que ajustarse en una muestra o en una hoja de papel.



Esta nueva funcionalidad requiere un cambio a la función
Y-axis-column, para añadir vertical-step para
eso. Esta función es parece a esto:




 
;;; Versión Final.
(defun Y-axis-column
  (height width-of-label &optional vertical-step)
  "Construye una lista de etiquetas para el eje Y.
HEIGHT es la máxima altura del grafo.
WIDTH-OF-LABEL es el máximo ancho de la etiqueta.
VERTICAL-STEP, una opción, es un entero positivo
que especifica cuanto una etiqueta de eje Y incrementa
cada línea. Por ejemplo, un paso de 5 
significa que cada línea es cinco unidades
del grafo."

  (let (Y-axis
        (number-per-line (or vertical-step 1)))
    (while (> height 1)
      (if (zerop (% height Y-axis-label-spacing))

          ;; Inserta etiqueta.
          (setq Y-axis
                (cons
                 (Y-axis-element
                  (* height number-per-line)
                  width-of-label)
                 Y-axis))

        ;; Else, inserta espacios en blanco.
        (setq Y-axis
              (cons
               (make-string width-of-label ? )
               Y-axis)))
      (setq height (1- height)))

    ;; Inserta línea base.
    (setq Y-axis (cons (Y-axis-element
                        (or vertical-step 1)
                        width-of-label)
                       Y-axis))
    (nreverse Y-axis)))




Los valores para la máxima altura del grafo y el ancho de un
símbolo son computados por print-graph es su
expresión let; así graph-body-print debe
ser cambiado para aceptarlos.




 
;;; Versión Final.
(defun graph-body-print (numbers-list height symbol-width)
  "Imprime una gráfica de barras del NUMBERS-LIST.
El numbers-list consiste en los valores del eje Y.
HEIGHT es la máxisma altura del grafo.
SYMBOL-WIDTH es el número de cada columna."

  (let (from-position)
    (while numbers-list
      (setq from-position (point))
      (insert-rectangle
       (column-of-graph height (car numbers-list)))
      (goto-char from-position)
      (forward-char symbol-width)

      ;; Dibuja el grafo columna por columna.
      (sit-for 0)
      (setq numbers-list (cdr numbers-list)))
    ;; Posiciona el punto para las etiquetas del eje X.
    (forward-line height)
    (insert "\n")))




Finalmente, el código para la función print-graph:




 
;;; Versión Final.
(defun print-graph
  (numbers-list &optional vertical-step)
  "El gráfico de barras etiquetadas del NUMBERS-LIST.
El numbers-list consiste en los valores de eje Y.

Opcionalmente, VERTICAL-STEP, un entero positivo, especifica cuanto el
eje Y incrementa cada línea. Por ejemplo, un paso de 5
significa que cada fila es de cinco unidades.
  (let* ((symbol-width (length graph-blank))
         ;; height en ambos es el número más largo
         ;; y el número con la mayoría de los digitos.
         (height (apply 'max numbers-list))

         (height-of-top-line
          (if (zerop (% height Y-axis-label-spacing))
              height
            ;; else
            (* (1+ (/ height Y-axis-label-spacing))
               Y-axis-label-spacing)))

         (vertical-step (or vertical-step 1))
         (full-Y-label-width
          (length

           (concat
            (number-to-string
             (* height-of-top-line vertical-step))
            Y-axis-tic))))

    (print-Y-axis
     height-of-top-line full-Y-label-width vertical-step)

    (graph-body-print
     numbers-list height-of-top-line symbol-width)
    (print-X-axis numbers-list)))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4.1 Testeando print-graph



Se puede chequear la función print-graph con una lista
ordenada de números:



    

  1. 
Instala las versiones finales de Y-axis-column,
graph-body-print, y print-graph (además del resto del
código.)


  2. 
Copia la siguiente expresión:


     
    (print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1))

    


  3. 
Cambia al búffer ‘*scratch*’ y emplaza el cursor donde se
quiere el eje etiquetado para empezar. 


  4. 
Escribe M-: (eval-expression).


  5. 
Pega la expresión de test dentro del minibuffer con C-y
(yank).


  6. 
Presiona <RET> para evaluar la expresión




Emacs imprimirá un grafo que se parece a esto:



 
10 -


         *
        **   *
 5 -   ****  *
       **** ***
     * *********
     ************
 1 - *************

     |   |    |    |
     1   5   10   15




Por otro lado, si se pasa a print-graph un vertical-step
valor de 2, evaluando esta expresión:



 
(print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1) 2)




El grafo se parece a esto:



 
20 -


         *
        **   *
10 -   ****  *
       **** ***
     * *********
     ************
 2 - *************

     |   |    |    |
     1   5   10   15




(Una pregunta: ¿es el `2' debajo del eje vertical un error o una
funcionalidad? Si se piensa que es un error, y sería un
`1', (o incluso un `0'), se pueden modificar las fuentes.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4.2 Creando Gráficas de Números de Palabras y Símbolos



Ahora para el gráfico para el que todo este código fué escrito:
un gráfico que muestra cuantas definiciones de función contienen
unas pocas 10 palabras y símbolos, cuantas contienen
entre 10 y 19 palabras y símbolos, cuantos contienen
entre 20 y 29 palabras y símbolos, y así.



Esto es un proceso de múltiples pasos. Primero asegúrate que has
cargado todo el requisito del código.



Eso es una buena idea para eliminar el valor de top-of-ranges
en caso de que has asignado a algún valor diferente. Se puede
evaluar lo siguiente:



 
(setq top-of-ranges
 '(10  20  30  40  50
   60  70  80  90 100
  110 120 130 140 150
  160 170 180 190 200
  210 220 230 240 250
  260 270 280 290 300)




Lo siguiente crea una lista del número de palabras y
símbolos en cada rango.



Evalúa lo siguiente:



 
(setq list-for-graph
       (defuns-per-range
         (sort
          (recursive-lengths-list-many-files
           (directory-files "/usr/local/emacs/lisp"
                            t ".+el$"))
          '<)
         top-of-ranges))




En mi vieja máquina, esto lleva como una hora. Se parece a 303
fichero Lisp en mi copia de Emacs version 19.23. Después de toda
esta computación, el list-for-graph tenía este valor:



 
(537 1027 955 785 594 483 349 292 224 199 166 120 116 99
90 80 67 48 52 45 41 33 28 26 25 20 12 28 11 13 220)




Esto significa que mi copia de Emacs tiene 537 definiciones de
funciones con poco de 10 palabras o símbolos en
sí, 1027 definiciones de función con 10 a 19 palabras
o símobolos dentro, 955 definiciones de función con 20
a 29 palabras o símbolos dentro, y así.



Claramente, solo buscando esta lista se puede ver que la
mayoría de definiciones de función contienen de diez a
treinta palabras y símbolos.



Ahora para imprimir. Nosotros no queremos imprimir un grafo que
es de 1030 líneas de alto …. En vez de eso,
imprimiría un grafo que es mejor que venticinco
líneas de alto. Un grafo cuya altura puede ser mostrada
en casi cualquier monitor, y fácilmente impreso en una hoja de papel.



Esto significa que cada valor en list-for-graph debe ser
reducido a un quinceavo de su valor presente.



Aquí hay una corta función para hacer esto, usando dos
funciones que no se han visto todavía, mapcar y
lambda.



 
(defun one-fiftieth (full-range)
  "Devuelve la lista, con el cincuenteavo de cada elemento."
 (mapcar '(lambda (arg) (/ arg 50)) full-range))









[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4.3 Una Expresión lambda: Anonimicidad Útil





lambda es el símbolo para una función
anónima, una función sin un nombre. Cada que se use una función
anónima, se necesita incluir su cuerpo completo.



De este modo,



 
(lambda (arg) (/ arg 50))




es una definición de función que dice `devuelve el valor
resultante de dividir cualquier cosa que es pasada como arg por
50'.



Pronto, por ejemplo, se tenía una función
multiply-by-seven; se multiplica su argumento por 7. Esta
función es similar, excepto que divide su argumento por 50; y, no
tiene nombre. El equivalente anónimo de multiply-by-seven es:



 
(lambda (number) (* 7 number))




(Véase la sección  La Forma Especial defun.)



Si queremos multiplicar 3 por 7, podemos escribir:



 
(multiply-by-seven 3)
 \_______________/ ^
         |         |
      función  argumento








Esta expresión devuelve 21.



De manera similar, se puede escribir:



 
((lambda (number) (* 7 number)) 3)
 \____________________________/ ^
               |                |
      función anónima     argumento








Si queremos dividir 100 por 50, se puede escribir:



 
((lambda (arg) (/ arg 50)) 100)
 \______________________/  \_/
             |              |
     función anónima   argumento








Esta expresión devuelve 2. El 100 es pasado para la función, que
divide este número por 50.



Véase (elisp)Expresiones Lambda sección `Expresiones Lambda' en El Manual de Referencia GNU Emacs Lisp, para más acerca de lambda. Lisp y
expresiones Lambda se derivan del Cálculo Lambda.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4.4 La Función mapcar




mapcar es una función que llama a su primer argumento con
cada elemento de su segundo argumento, en vez. El segundo argumento
debe ser una secuencia.



La parte ‘map’ del nombre venga desde la frase matemática,
`mapeando a través de un dominio', significa hace apply a una
función a cada uno de los elementos en un dominio. La frase
matemática está basada en la metáfora de un superviviente
paseando, un paso en un momento, a través de un área él está
mapeando. Y ‘car’, de acuerdo, viene desde la noción Lisp del
primero de una lista.



Por ejemplo,



 
(mapcar '1+ '(2 4 6))
     ⇒ (3 5 7)




La función 1+ que añade uno a su argumento, es ejecutado en
each de la lista, y una nueva lista es devuelta.



Contrasta esto con apply, que aplica su primer argumento a todo
lo que permanece. (Véase la sección  Leyendo un Grafo, para
una explicación de apply.)



En la definición de one-fiftieth, el primer argumento es la
función anónima:



 
(lambda (arg) (/ arg 50))




y el segundo argumento es full-range, que será asociado para
list-for-graph.



La expresión completa se parece a esto:



 
(mapcar '(lambda (arg) (/ arg 50)) full-range))




Véase (elisp)Funciones de Mapeo sección `Mapeando Funciones' en El Manual de Referencia de GNU Emacs Lisp, para más acerca de mapcar.



Usando la función one-fiftieth, se puede generar una lista en
el que cada elemento es un cincuenteavo del tamaño del
correspondiente elemento en list-for-graph.



 
(setq fiftieth-list-for-graph
      (one-fiftieth list-for-graph))




La lista resultante se parece a esto:



 
(10 20 19 15 11 9 6 5 4 3 3 2 2
1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 4)




Así, ¡ya estamos casi listos para imprimir! (También se
notifica la
pérdida de información: muchos de los rangos superiores son 0,
esto significa que menos de 50 funciones tenían muchas
palabras o símbolos --- pero no necesariamente
significando que niguna tenía muchas palabras o
símbolos.)








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4.5 Otro Error … Más Insidioso





Se dijo `casi listo para imprimir' De acuerdo, hay un error en la
función print-graph …. Esto tiene una opción
vertical-step, pero no una opción horizontal-step. La
escala top-of-range va desde 10 a 300 por diez. Pero la
función print-graph imprimirá solo por uno.



Esto es un ejemplo clásico de lo que algunos consideramos el tipo
más insidioso de error, el error de omisión. Esto no es el tipo de
error que se puede encontrar estudiando el código, para eso no es el
código; es una funcionalidad omitida. Tus mejores acciones son
probar tu programa pronto y con frecuencia; e intentar poner en orden,
tanto como se pueda, escribir código que sea fácil de comprender y
fácil de cambiar. Intenta ser consciente, siempre y cuando se pueda,
esto es siempre que tengas que escribir, será reescrito, si
no pronto, eventualmente. Un máximo duro de seguir.



Esta el la función print-X-axis-numbered-line que necesita el
trabajo; y entonces el print-X-axis y la función
print-graph necesita ser adaptada. No se necesita mucho para
ser hecho; hay uno simpático: los números podrían
alinearse con marcas de tic. Esto toma un pequeño pensamiento.



Aquí está el print-X-axis-numbered-line corregido:



 
(defun print-X-axis-numbered-line
  (number-of-X-tics X-axis-leading-spaces
   &optional horizontal-step)
  "Imprime la líneas de números X-axis"
  (let ((number X-axis-label-spacing)
        (horizontal-step (or horizontal-step 1)))

    (insert X-axis-leading-spaces)
    ;; Elimina espacios extra de guía.
    (delete-char
     (- (1-
         (length (number-to-string horizontal-step)))))
    (insert (concat
             (make-string

              ;; Insertar espacio en blanco.
              (-  (* symbol-width
                     X-axis-label-spacing)
                  (1-
                   (length
                    (number-to-string horizontal-step)))
                  2)
              ? )
             (number-to-string
              (* number horizontal-step))))

    ;; Insertar los número que permanecen.
    (setq number (+ number X-axis-label-spacing))
    (while (> number-of-X-tics 1)
      (insert (X-axis-element
               (* number horizontal-step)))
      (setq number (+ number X-axis-label-spacing))
      (setq number-of-X-tics (1- number-of-X-tics)))))




Si estás leyendo esto en Info, se puede ver las nuevas versiones
print-X-axis print-graph y los evalúas. Si estás
leyendo esto en un libro impreso, se pueden ver las
líneas cambiadas aquí (el texto completo
es mucho para imprimir).




 
(defun print-X-axis (numbers-list horizontal-step)
  "Imprime etiquetas del eje X a la longitud de NUMBERS-LIST.
Opcionalmente, HORIZONTAL-STEP, un entero positivo,
especifica cuanto una etiqueta del eje X incrementa 
cada columna."

;; Valor del símbolo symbol-width and full-Y-label-width
;; se pasan por `print-graph'.
  (let* ((leading-spaces
          (make-string full-Y-label-width ? ))
       ;; symbol-width is provided by graph-body-print
       (tic-width (* symbol-width X-axis-label-spacing))
       (X-length (length numbers-list))

       (X-tic
        (concat
         (make-string
          ;; Crea una cadena de espacios en blanco.
          (-  (* symbol-width X-axis-label-spacing)
              (length X-axis-tic-symbol))
          ? )

         ;; Concatena espacios en blanco con el
         símbolo tic.
         X-axis-tic-symbol))
       (tic-number
        (if (zerop (% X-length tic-width))
            (/ X-length tic-width)
          (1+ (/ X-length tic-width)))))

    (print-X-axis-tic-line
     tic-number leading-spaces X-tic)
    (insert "\n")
    (print-X-axis-numbered-line
     tic-number leading-spaces horizontal-step)))




 
(defun print-graph
  (numbers-list &optional vertical-step horizontal-step)
  "Imprime el gráfico de barras etiquetada de los NUMBERS-LIST.
Los numbers-list consiste de lo valores eje Y."

Opcionalmente, VERTICAL-STEP, un entero positivo, especifica cuanto un
eje Y se incrementa por cada línea. Por ejemplo, un paso
de 5 significa que cada fila es de cinco unidades.
Opcionalmente, HORIZONTAL-STEP, un entero positivo,
especifica cuanto se incrementa en un eje X cada columna."
  (let* ((symbol-width (length graph-blank))
         ;; height es ambos el número más largo
         ;; y el número con la mayoría de los dígitos.
         (height (apply 'max numbers-list))

         (height-of-top-line
          (if (zerop (% height Y-axis-label-spacing))
              height
            ;; else
            (* (1+ (/ height Y-axis-label-spacing))
               Y-axis-label-spacing)))

         (vertical-step (or vertical-step 1))
         (full-Y-label-width
          (length
           (concat
            (number-to-string
             (* height-of-top-line vertical-step))
            Y-axis-tic))))

    (print-Y-axis
     height-of-top-line full-Y-label-width vertical-step)
    (graph-body-print
        numbers-list height-of-top-line symbol-width)
    (print-X-axis numbers-list horizontal-step)))











[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




C.4.6 El Gráfico Impreso



Cuando esté hecho e instalado, se puede llamar al comando
print-graph como esto:





 
(print-graph fiftieth-list-for-graph 50 10)






Aquí está el gráfico:







 
1000 -  *
        **
        **
        **
        **
 750 -  ***
        ***
        ***
        ***
        ****
 500 - *****
       ******
       ******
       ******
       *******
 250 - ********
       *********                     *
       ***********                   *
       *************                 *
  50 - ***************** *           *
       |   |    |    |    |    |    |    |
      10  50  100  150  200  250  300  350









El grupo largo de funciones contienen de 10 a 19 palabras y
símbolos.








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




D. Software Libre y Manuales Libres



por Richard M. Stallman





La mayor deficiencia en sistemas operativos libres no está en el
software --- esa es la falta de buenos manuales libres que se pueden
incluir en estos sistemas. Mucho de nuestros programas más
importantes no vienen con manuales completos. La documentación es
una parte esencial de cualquier paquete de software; cuando un
paquete de software libre no viene con un manual libre, esto es una
brecha mayor. Nosotros tenemos muchas brechas hoy.



Érase una vez, hace muchos años, se piensa que
aprendería Perl. Se tiene una copia de un manual libre,
pero se encontró difícil de leer. Cuando pregunto a
los usuarios de Perl acerca de alternativas, me contaron que
serían mejor los manuales introductorios --- pero estos
no eran libres.



¿Por qué era esto? Los autores de los buenos manuales
los habían escrito para O'Reilly Associates, que los
publicaron con términos restrictivos --- no copiando, no
modificando, los ficheros fuentes están disponibles --- que los
excluyen desde la comunidad de software libre.



Esto no era la primera vez que esto ocurría, y (para
nuestra comunidad es una gran pérdida) eso está lejos desde el
último. Las editoriales de manuales privativos han logrado que
muchos autores restrinjan sus manuales desde entonces. Muchas veces se
ha oido que un usuario de GNU hábil me cuente que un manual que
está escribiendo, con el que él espera ayudar al proyecto GNU ---
y entonces tenía mis esperanzas frustradas, como él
procedió a explicar que él tenía que haber firmado
un contrato con una editorial que restringiría eso,
así que no puede usarlo.



Debido a que escribir buen inglés una habilidad rara entre
programadores, se pueden perder manuales por esto.



La documentación, como el software, es una cuestión de libertad,
no de precio. El problema con estos manuales no eran los que O'Reilly
Associates impusiera un precio por las copias impresas --- que en
sí estaban bien. La Free Software Foundation
Fundación por el Software Libre vende copias impresas de manuales libres de GNU, también. Pero los manuales de GNU están
disponibles en forma de código fuente, mientras estos manuales
están disponibles solo en papel. Los manuales de GNU viene con
permisos para copiar y modificar; los manuales de Perl no. Estas
restricciones son problemas.



El criterio para un manual libre es parecido al del software libre: es
una cuestión de dar a todos los usuarios ciertas libertades. La
redistribución (incluyendo redistribución comercial) debe ser
permitida, así el manual puede acompañar cada copia
del programa, en líne o en papel. Permiso para modificar
es crucial también.



Como regla general, no se cree que sea esencial para la gente tener
permisos para modificar todas las partes de artículos y
libro. Las cuestiones para escritos no son necesariamente las mismas
como estas para el software. Por ejemplo, no se sabe si se está
obligado a dar permisos para modificar artículos como
este, que describen nuestras acciones y nuestras vistas.



Pero hay una razón particular de por qué la libertad de modificar
es crucial para la documentación de software libre. Cuando las
personas ejercita su derecho a modificar el software, y añadir o
cambiar sus funcionalidades, si son consciente ellos cambiarán el
manual también --- así se puede proveer
documentación usable y cuidada con el programa modificado. Un manual
que prohibe a los programadores ser consciente y finalizar el trabajo,
o más precisamente requiere escribir un nuevo manual desde cero si
ellos cambian el programa, no se ajusta a las necesidades de nuestra
comunidad.



Mientras una serie de prohibiciones en la modificación es
inaceptable, algunos tipos de límites en el método de
modificar no tiene tanto problema. Por ejemplo, los requisitos para
preservar la noticia de autores del copyright, los términos de
distribución, o la lista de autores, estén ok. Eso es también no
da problemas para requerir versiones modificadas para incluir
notificar que fueron modificadas, incluso tienen secciones enteras que
puede no ser eliminadas o cambiadas, tan largo como estas secciones
tratan con asuntos no técnicos. (Algunos manuales de GNU los tienen).



Estos tipos de restricciones no son un problema porque, como materia
práctica, no para al programador consciente desde la adaptación
del manual para ajustar el programa modificado. En otras palabras, no
se bloquea la comunidad del software libre haciendo el uso completo
del manual.



Sin embargo, debe ser posible modificar todo el contenido técnico
del manual, y entonces se distribuye el resultado en todos los medios
usuales, a través de todos los canales usuales; de otro modo, las
restricciones bloquean la comunidad, el manual no es libre, y
así no se necesita otro manual.



Desafortunadamente, con frecuencia es duro encontrar a alguien a
escribir otro manual cuando un manual privativo. El obstáculo es que
muchos usuario piensan que un manual privativo es suficientemente
bueno --- así ellos no ven la necesidad de escribir un
manual libre. Ellos no ven que el sistema operativo tiene un gazapo
que necesita se rellenado.



\textquestiondownPor qué los usuarios piensan que los manuales
privativos son suficientemente buenos? Algunos no han considerado la
cuestión. Espero que este artículo hará alguna cosa
para cambiar esto.



Otros usuarios considera manuales privativos aceptables para la misma
razón así muchas personas software privativo
aceptable: ellos judgan en términos puramente prácticos, no usando
la liberta como un criterio. Estas personas son tituladas a sus
opiniones, pero desde que estas opciones crezcan desde valores que no
incluyen libertad, ellas no están guiadas por esto quienes valoran
la libertad.



Por favor, populariza esta cuestión. Se continúa a perder manuales
para publicación privativa. Si se populariza que los manuales
privativos no son suficientes, quizás la siguiente persona que
quiere ayudar a GNU escribiendo documentación realizará, antes de
que sea demasiado tarde, lo que él debe que todo sea libre.



Se puede también animar editoriales comerciales a vender manuales
libres o con copyleft en vez de uno privativo. Un camino que se puede
ayudar esto chequea los términos de la distribución de un manual
antes de que se compre, y preferimos manuales copyleft a los no copyleft.







Note: La Fundación para el Software Libre mantiene una página en
su sitio Web que liste libros libres disponibles desde otras
editoriales:
 http://www.gnu.org/doc/other-free-books.html








[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




E. GNU Free Documentation License




 Version 1.3, 3 November 2008




 
Copyright © 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
http://fsf.org/

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.




    

  1. 
PREAMBLE


    The purpose of this License is to make a manual, textbook, or other
functional and useful document free in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.

    

    This License is a kind of ``copyleft'', which means that derivative
works of the document must themselves be free in the same sense.  It
complements the GNU General Public License, which is a copyleft
license designed for free software.

    

    We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does.  But this License is not limited to software manuals;
it can be used for any textual work, regardless of subject matter or
whether it is published as a printed book.  We recommend this License
principally for works whose purpose is instruction or reference.

    

  2. 
APPLICABILITY AND DEFINITIONS


    This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License.  Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein.  The ``Document'', below,
refers to any such manual or work.  Any member of the public is a
licensee, and is addressed as ``you''.  You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.

    

    A ``Modified Version'' of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.

    

    A ``Secondary Section'' is a named appendix or a front-matter section
of the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall
subject (or to related matters) and contains nothing that could fall
directly within that overall subject.  (Thus, if the Document is in
part a textbook of mathematics, a Secondary Section may not explain
any mathematics.)  The relationship could be a matter of historical
connection with the subject or with related matters, or of legal,
commercial, philosophical, ethical or political position regarding
them.

    

    The ``Invariant Sections'' are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License.  If a
section does not fit the above definition of Secondary then it is not
allowed to be designated as Invariant.  The Document may contain zero
Invariant Sections.  If the Document does not identify any Invariant
Sections then there are none.

    

    The ``Cover Texts'' are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License.  A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.

    

    A ``Transparent'' copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or
for automatic translation to a variety of formats suitable for input
to text formatters.  A copy made in an otherwise Transparent file
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
of text.  A copy that is not ``Transparent'' is called ``Opaque''.

    

    Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input
format, SGML or XML using a publicly available
DTD, and standard-conforming simple HTML,
PostScript or PDF designed for human modification.  Examples
of transparent image formats include PNG, XCF and
JPG.  Opaque formats include proprietary formats that can be
read and edited only by proprietary word processors, SGML or
XML for which the DTD and/or processing tools are
not generally available, and the machine-generated HTML,
PostScript or PDF produced by some word processors for
output purposes only.

    

    The ``Title Page'' means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page.  For works in
formats which do not have any title page as such, ``Title Page'' means
the text near the most prominent appearance of the work's title,
preceding the beginning of the body of the text.

    

    The ``publisher'' means any person or entity that distributes copies
of the Document to the public.

    

    A section ``Entitled XYZ'' means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language.  (Here XYZ stands for a
specific section name mentioned below, such as ``Acknowledgements'',
``Dedications'', ``Endorsements'', or ``History''.)  To ``Preserve the Title''
of such a section when you modify the Document means that it remains a
section ``Entitled XYZ'' according to this definition.

    

    The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document.  These Warranty
Disclaimers are considered to be included by reference in this
License, but only as regards disclaiming warranties: any other
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.

    

  3. 
VERBATIM COPYING


    You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies
to the Document are reproduced in all copies, and that you add no other
conditions whatsoever to those of this License.  You may not use
technical measures to obstruct or control the reading or further
copying of the copies you make or distribute.  However, you may accept
compensation in exchange for copies.  If you distribute a large enough
number of copies you must also follow the conditions in section 3.

    

    You may also lend copies, under the same conditions stated above, and
you may publicly display copies.

    

  4. 
COPYING IN QUANTITY


    If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover.  Both covers must also clearly and legibly identify
you as the publisher of these copies.  The front cover must present
the full title with all words of the title equally prominent and
visible.  You may add other material on the covers in addition.
Copying with changes limited to the covers, as long as they preserve
the title of the Document and satisfy these conditions, can be treated
as verbatim copying in other respects.

    

    If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto adjacent
pages.

    

    If you publish or distribute Opaque copies of the Document numbering
more than 100, you must either include a machine-readable Transparent
copy along with each Opaque copy, or state in or with each Opaque copy
a computer-network location from which the general network-using
public has access to download using public-standard network protocols
a complete Transparent copy of the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps,
when you begin distribution of Opaque copies in quantity, to ensure
that this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you distribute an
Opaque copy (directly or through your agents or retailers) of that
edition to the public.

    

    It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to give
them a chance to provide you with an updated version of the Document.

    

  5. 
MODIFICATIONS


    You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy
of it.  In addition, you must do these things in the Modified Version:

    

      

    1. 
Use in the Title Page (and on the covers, if any) a title distinct
from that of the Document, and from those of previous versions
(which should, if there were any, be listed in the History section
of the Document).  You may use the same title as a previous version
if the original publisher of that version gives permission.


    2. 
List on the Title Page, as authors, one or more persons or entities
responsible for authorship of the modifications in the Modified
Version, together with at least five of the principal authors of the
Document (all of its principal authors, if it has fewer than five),
unless they release you from this requirement.


    3. 
State on the Title page the name of the publisher of the
Modified Version, as the publisher.


    4. 
Preserve all the copyright notices of the Document.


    5. 
Add an appropriate copyright notice for your modifications
adjacent to the other copyright notices.


    6. 
Include, immediately after the copyright notices, a license notice
giving the public permission to use the Modified Version under the
terms of this License, in the form shown in the Addendum below.


    7. 
Preserve in that license notice the full lists of Invariant Sections
and required Cover Texts given in the Document's license notice.


    8. 
Include an unaltered copy of this License.


    9. 
Preserve the section Entitled ``History'', Preserve its Title, and add
to it an item stating at least the title, year, new authors, and
publisher of the Modified Version as given on the Title Page.  If
there is no section Entitled ``History'' in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.


    10. 
Preserve the network location, if any, given in the Document for
public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions
it was based on.  These may be placed in the ``History'' section.
You may omit a network location for a work that was published at
least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.


    11. 
For any section Entitled ``Acknowledgements'' or ``Dedications'', Preserve
the Title of the section, and preserve in the section all the
substance and tone of each of the contributor acknowledgements and/or
dedications given therein.


    12. 
Preserve all the Invariant Sections of the Document,
unaltered in their text and in their titles.  Section numbers
or the equivalent are not considered part of the section titles.


    13. 
Delete any section Entitled ``Endorsements''.  Such a section
may not be included in the Modified Version.


    14. 
Do not retitle any existing section to be Entitled ``Endorsements'' or
to conflict in title with any Invariant Section.


    15. 
Preserve any Warranty Disclaimers.

    


    If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant.  To do this, add their titles to the
list of Invariant Sections in the Modified Version's license notice.
These titles must be distinct from any other section titles.

    

    You may add a section Entitled ``Endorsements'', provided it contains
nothing but endorsements of your Modified Version by various
parties---for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.

    

    You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list
of Cover Texts in the Modified Version.  Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or
through arrangements made by) any one entity.  If the Document already
includes a cover text for the same cover, previously added by you or
by arrangement made by the same entity you are acting on behalf of,
you may not add another; but you may replace the old one, on explicit
permission from the previous publisher that added the old one.

    

    The author(s) and publisher(s) of the Document do not by this License
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.

    

  6. 
COMBINING DOCUMENTS


    You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and
list them all as Invariant Sections of your combined work in its
license notice, and that you preserve all their Warranty Disclaimers.

    

    The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single
copy.  If there are multiple Invariant Sections with the same name but
different contents, make the title of each such section unique by
adding at the end of it, in parentheses, the name of the original
author or publisher of that section if known, or else a unique number.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.

    

    In the combination, you must combine any sections Entitled ``History''
in the various original documents, forming one section Entitled
``History''; likewise combine any sections Entitled ``Acknowledgements'',
and any sections Entitled ``Dedications''.  You must delete all
sections Entitled ``Endorsements.''

    

  7. 
COLLECTIONS OF DOCUMENTS


    You may make a collection consisting of the Document and other documents
released under this License, and replace the individual copies of this
License in the various documents with a single copy that is included in
the collection, provided that you follow the rules of this License for
verbatim copying of each of the documents in all other respects.

    

    You may extract a single document from such a collection, and distribute
it individually under this License, provided you insert a copy of this
License into the extracted document, and follow this License in all
other respects regarding verbatim copying of that document.

    

  8. 
AGGREGATION WITH INDEPENDENT WORKS


    A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
distribution medium, is called an ``aggregate'' if the copyright
resulting from the compilation is not used to limit the legal rights
of the compilation's users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.

    

    If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
the entire aggregate, the Document's Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
aggregate.

    

  9. 
TRANSLATION


    Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include
translations of some or all Invariant Sections in addition to the
original versions of these Invariant Sections.  You may include a
translation of this License, and all the license notices in the
Document, and any Warranty Disclaimers, provided that you also include
the original English version of this License and the original versions
of those notices and disclaimers.  In case of a disagreement between
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.

    

    If a section in the Document is Entitled ``Acknowledgements'',
``Dedications'', or ``History'', the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.

    

  10. 
TERMINATION


    You may not copy, modify, sublicense, or distribute the Document
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense, or distribute it is void, and
will automatically terminate your rights under this License.

    

    However, if you cease all violation of this License, then your license
from a particular copyright holder is reinstated (a) provisionally,
unless and until the copyright holder explicitly and finally
terminates your license, and (b) permanently, if the copyright holder
fails to notify you of the violation by some reasonable means prior to
60 days after the cessation.

    

    Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

    

    Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, receipt of a copy of some or all of the same material does
not give you any rights to use it.

    

  11. 
FUTURE REVISIONS OF THIS LICENSE


    The Free Software Foundation may publish new, revised versions
of the GNU Free Documentation License from time to time.  Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.  See
http://www.gnu.org/copyleft/.

    

    Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
License ``or any later version'' applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation.  If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation.  If the Document
specifies that a proxy can decide which future versions of this
License can be used, that proxy's public statement of acceptance of a
version permanently authorizes you to choose that version for the
Document.

    

  12. 
RELICENSING


    ``Massive Multiauthor Collaboration Site'' (or ``MMC Site'') means any
World Wide Web server that publishes copyrightable works and also
provides prominent facilities for anybody to edit those works.  A
public wiki that anybody can edit is an example of such a server.  A
``Massive Multiauthor Collaboration'' (or ``MMC'') contained in the
site means any set of copyrightable works thus published on the MMC
site.

    

    ``CC-BY-SA'' means the Creative Commons Attribution-Share Alike 3.0
license published by Creative Commons Corporation, a not-for-profit
corporation with a principal place of business in San Francisco,
California, as well as future copyleft versions of that license
published by that same organization.

    

    ``Incorporate'' means to publish or republish a Document, in whole or
in part, as part of another Document.

    

    An MMC is ``eligible for relicensing'' if it is licensed under this
License, and if all works that were first published under this License
somewhere other than this MMC, and subsequently incorporated in whole
or in part into the MMC, (1) had no cover texts or invariant sections,
and (2) were thus incorporated prior to November 1, 2008.

    

    The operator of an MMC Site may republish an MMC contained in the site
under CC-BY-SA on the same site at any time before August 1, 2009,
provided the MMC is eligible for relicensing.

    






ADDENDUM: How to use this License for your documents



To use this License in a document you have written, include a copy of
the License in the document and put the following copyright and
license notices just after the title page:



 
  Copyright (C)  year  your name.
  Permission is granted to copy, distribute and/or modify this document
  under the terms of the GNU Free Documentation License, Version 1.3
  or any later version published by the Free Software Foundation;
  with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
  Texts.  A copy of the license is included in the section entitled ``GNU
  Free Documentation License''.




If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
replace the ``with…Texts.'' line with this:



 
    with the Invariant Sections being list their titles, with
    the Front-Cover Texts being list, and with the Back-Cover Texts
    being list.




If you have Invariant Sections without Cover Texts, or some other
combination of the three, merge those two alternatives to suit the
situation.



If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of
free software license, such as the GNU General Public License,
to permit their use in free software.












[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Indice'




Saltar a:   %
   
(
   
*
   
/
   
<
   
>
   


A
   
B
   
C
   
D
   
E
   
F
   
G
   
H
   
I
   
K
   
L
   
M
   
N
   
O
   
P
   
R
   
S
   
T
   
V
   
W
   
X
   
Y
   
Z
   





Entrada de índice Sección


 


%


% (función recuerdo)C.2.1 Viaje Lateral: Computa un Recuerdo


 


(


(debug) en código17.3 debug-on-quit y (debug)


 


*


* (multiplicación)3.1 La Forma Especial defun


* para buffer solo lecturaUn Búffer de Solo lectura


‘*scratch*’ buffer11.1.2 Un Ejemplo: print-elements-of-list


 


/


/ (division)Qué ocurre en búffer largo


 


<


<= (menos que igual)Las partes de la definición de función


 


>


> (mayor que)if en más detalle


 


A


Átomos Lisp1.1.1 Átomos Lisp


Acumular, escribe patrón recursivoPatrón Recursivo: accumulate


add-hook16.4 Modo Texto y Auto Relleno


Alias de Correo16.5 Alias de Correo


Almacenando y cortando texto8. Cortando y Almacenando Texto


Ampliando6. Extendiendo y Encogiendo


andLa función kill-new


andLa expresión let*


Anillo, creando un lista como unB. Manejando el Anillo de la Muerte


append-to-buffer4.4 La Definición de append-to-buffer


applyImprimiendo las Columnas de un Grafo


aproposImprimiendo las Columnas de un Grafo


Argumento como variable localPoniendo la definición de la función junta


‘argumento’ definido1.8 Argumentos


Argumento, tipo incorrecto de1.8.4 Usando el Tipo Incorrecto de Objeto como un Argumento


Argumentos1.8 Argumentos


Argumentos de tipos datos1.8.1 Tipos de Argumentos de Datos


Argumentos Opcionales5.3.1 Argumentos Opcionales


Argumentos, número variable de1.8.3 Número de Variables de Argumentos


Asignando tecla globalmente16.7 Algunos Atajos


Asignando valor de variable1.9 Configurando el Valor de una Variable


Asignar tecla global16.7 Algunos Atajos


Asociaciones, teclas, arreglandoArreglando Atajos de Teclados


Asterisco para búffer de solo lecturaUn Búffer de Solo lectura


Atajos de Teclado, arreglandoArreglando Atajos de Teclados


autoload16.10 Autoloading


Ayuda escribiendo listas1.1.3 GNU Emacs te Ayuda a Escribir Listas


 


B


beginning-of-buffer5.3 Definición Completa de beginning-of-buffer


‘bind’ se definió1.9 Configurando el Valor de una Variable


Borrando texto8. Cortando y Almacenando Texto


Borrando texto8. Cortando y Almacenando Texto


Búsquedas de expresiones regulares12. Búsquedas de Expresiones Regulares


Búsquedas, ilustrando12. Búsquedas de Expresiones Regulares


Bucles11.1 mientras


Bucles y recursión11. Bucles y Recursión


buffer solo lecturaUn Búffer de Solo lectura


Buffer, historia de palabra2.1 Nombres de Buffer


buffer-file-name2.1 Nombres de Buffer


buffer-menu, asociado a tecla16.7 Algunos Atajos


buffer-name2.1 Nombres de Buffer


 


C


C, una disgresión dentro8.4 Disgresión dentro C


Cada, tipo de patrón recursivoPatrón Recursivo: cada


‘cadena’ definida1.1.1 Átomos Lisp


‘cadena vacía’ definida3.11 Revisar


Caja con Cajones, metáfora para su símbolo9.1 Símbolos como una Caja con Cajones


Cajones, Caja de, metáfora para un símbolo9.1 Símbolos como una Caja con Cajones


Cambiando a un búffer2.3 Cambiando Buffers


Cambiando una definición de función3.2.1 Cambiar una Definición de Función


cancel-debug-on-entry17.2 debug-on-entry


car, introducido7. car, cdr, cons: Funciones Fundamentales


Cargando ficheros16.9 Cargando Ficheros


Categorías de sintaxis y tablas14.2 ¿Qué Constituye un Palabra o Símbolo?


cdr, introducido7. car, cdr, cons: Funciones Fundamentales


Código de instalación3.5 Instalar Código Permanentemente


Código Permanente de Instalación3.5 Instalar Código Permanentemente


‘comando’ definidoCómo Evaluar


Comentarios en Código Lisp3.2.1 Cambiar una Definición de Función


Common LispHistoria de Lisp


compare-windows16.7 Algunos Atajos


Compilando Byte1.5.1 Compilación de Bytes


concatenar1.8.1 Tipos de Argumentos de Datos


cond11.3.5 Ejemplo de Recursión Usando cond


Condicional con if3.7 La Forma Especial if


Condicional marcarán estas dos versiones de Emacs16.11 Una Extensión Simple: line-to-top-of-window


condition-case8.2.1 condition-case


Configurando una tecla globalmente16.7 Algunos Atajos


cons, introducido7.2 cons


Construyendo Etiquetas en las fuentes EmacsConstruyendo Etiquetas en las fuentes Emacs


Construyendo robots11.3.1 Construyendo Robots: Extendiendo la Metáfora


Contando1.9.3 Contando


Contando las palabras en un defun14. Contando Palabras en una defun


Contando palabras en un defun14. Contando Palabras en una defun


Contando palabras en un defun14.3 La Función count-words-in-defun


Convención formateando4.4.3 save-excursion en append-to-buffer


Copiando texto8. Cortando y Almacenando Texto


copy-region-as-kill8.3 copy-region-as-kill


copy-to-buffer5.1 La Definición de copy-to-buffer


Cortando texto8. Cortando y Almacenando Texto


Cortando y almacenando texto8. Cortando y Almacenando Texto


count-words-in-defun14.3 La Función count-words-in-defun


count-words-region13.1 La Función count-words-region


crear etiquetasConstruyendo Etiquetas en las fuentes Emacs


Cuenta palabras recursivamente13.2 Cuenta Palabras Recursivamente


Cuerpo de grafo15. Leyendo un Grafo


‘cuerpo’ definido3.1 La Forma Especial defun


current-buffer2.2 Obteniendo Buffers


current-killB.1 La Función current-kill


 


D


debug-on-entry17.2 debug-on-entry


debug-on-quit17.3 debug-on-quit y (debug)


defconst16.2 Especificar Variables usando defcustom


defcustom16.2 Especificar Variables usando defcustom


Defermentar en recursión11.3.7 Recursión sin Defermentos


Definición de Función, como cambiar3.2.1 Cambiar una Definición de Función


Definición de la instalación3.2 Instalar una Definición de Función


Definición de la Instalación de Función3.2 Instalar una Definición de Función


‘definición función’ definida3.1 La Forma Especial defun


Definición, cómo cambiar3.2.1 Cambiar una Definición de Función


defsubst16.2 Especificar Variables usando defcustom


defun3.1 La Forma Especial defun


defvar8.5 Inicializando una Variable con defvar


defvar con un asterisco8.5.1 defvar y un asterisco


defvar para una variable personalizable8.5.1 defvar y un asterisco


delete-and-extract-region8.4 Disgresión dentro C


Depurador de nivel de código17.4 El Depurador de Nivel de Fuentes edebug


depurando17. Depurando


depurar17.1 depurar


Desasociar Tecla a Comando16.7 Algunos Atajos


describe-function4.2 Una Definición Simplificada beginning-of-buffer


describe-function, introducido4.1 Encontrando Más Información


directory-files14.9.2 Creando una Lista de Ficheros


Disgresión dentro C8.4 Disgresión dentro C


Disociando la tecla16.7 Algunos Atajos


DivisiónQué ocurre en búffer largo


dolistLa Macro dolist


dotimesLa Macro dotimes


 


E


edebug17.4 El Depurador de Nivel de Fuentes edebug


‘efecto lateral’ definidoCómo el Intérprete Actúa


Ejecuta un programa1.2 Ejecutar un Programa


Ejes, imprime horizontalC.3 La Función print-X-axis


Ejes, imprimir verticalC.2 La Función print-Y-axis


Else3.8 Expresiones If–then–else


Encogiendo6. Extendiendo y Encogiendo


Encontrar documentación de la función4.1 Encontrando Más Información


Encontrar la fuente de la función4.1 Encontrando Más Información


Encontrar un Fichero14.5 Encontrar un Fichero


eobpEl bucle while hacia adelante


eq3.11 Revisar


eq (example of use)last-command and this-command


errorEl cuerpo de current-kill


Error para símbolo sin función1.7.1 Mensaje de Error para un Símbolo sin una Función


Error para símbolo sin valor1.7.2 Mensaje de Error para un Símbolo sin un Valor


Error, del tipo más insidiosoC.4.5 Otro Error … Más Insidioso


Escribiendo la Definición3. Cómo Escribir Definiciones de Funciones


Escribiendo la Definición de Función3. Cómo Escribir Definiciones de Funciones


Escribiendo una definición función3. Cómo Escribir Definiciones de Funciones


Espacio en blanco en listas1.1.2 Espacios en blanco en Listas


etags12.5 Crea tu propio fichero ‘TAGS’


Etiquetas en las fuentes EmacsConstruyendo Etiquetas en las fuentes Emacs


Evaluación1.6 Evaluación


Evaluación de listas propias1.6.1 Evaluando Listas Propias


Evaluación práctica2. Practicando Evaluación


Evaluando listas propias1.6.1 Evaluando Listas Propias


‘expresión’ definida1.1.1 Átomos Lisp


expresión let, partes de3.6.1 Las Partes de una Expresión let


expresión simple let3.6.2 Expresión Simple let


Expresión Simple let3.6.2 Expresión Simple let


Expresiones regulares para contar palabras13. Contando: Repetición y Regexps


Expresiones simbólicas, introducidas1.1.1 Átomos Lisp


Extendiendo, ejemplo de6.2 what-line


Extensión simple en fichero ‘.emacs’16.11 Una Extensión Simple: line-to-top-of-window


 


F


Falsedad y verdad en Emacs Lisp3.9 Verdad y Falsedad en Emacs Lisp


FDL, GNU Free Documentation LicenseE. GNU Free Documentation License


fichero ‘.emacs’16. Tu Fichero ‘.emacs’


fichero ‘.emacs’, empezando16.3 Empieza por un Fichero ‘.emacs’


fichero de inicio ‘default.el’16.1 Fichero de Inicialización Site-wide


fichero de ‘TAGS’, crea el propio12.5 Crea tu propio fichero ‘TAGS’


Fichero inicialización16. Tu Fichero ‘.emacs’


fichero inicio ‘site-init.el’16.1 Fichero de Inicialización Site-wide


fichero ‘ring.el’B.4 El Fichero ‘ring.el’


fichero ‘site-load.el’16.1 Fichero de Inicialización Site-wide


files-in-below-directory14.9.2 Creando una Lista de Ficheros


fill-column, una variable de ejemplofill-column, un Ejemplo de Variable


filter-buffer-substringlast-command and this-command


find-tag4.1 Encontrando Más Información


Flores en un campo1.1 Listas Lisp


Focalizando atención (encogiendo)6. Extendiendo y Encogiendo


‘forma’ definida1.1.1 Átomos Lisp


Forma EspecialComplicaciones


Forma Especial de defun3.1 La Forma Especial defun


Formateando ayuda1.1.3 GNU Emacs te Ayuda a Escribir Listas


Formato de Modo Línea16.14 Una Línea Modificada


forward-paragraph12.4 forward-paragraph: una Mina de Oro de Funciones


forward-sentence12.3 forward-sentence


Frases, movimiento por12. Búsquedas de Expresiones Regulares


Función AnónimaC.4.3 Una Expresión lambda: Anonimicidad Útil


Función de palabras duplicadasA. La Función the-the


Función de Recuerdo, %C.2.1 Viaje Lateral: Computa un Recuerdo


‘función’ definida1.3 Generar un Mensaje de Error


‘función’ definida1.3 Generar un Mensaje de Error


‘función interactiva’ definidaCómo Evaluar


Funciones Interactivas3.3 Crear una Función Interactive


Funciones PrimitivasUna Vía acerca de Funciones Primitivas


Funciones, primitivaUna Vía acerca de Funciones Primitivas


 


G


Genera un mensaje de error1.3 Generar un Mensaje de Error


Generación de mensaje de Error1.3 Generar un Mensaje de Error


global-set-key16.7 Algunos Atajos


global-unset-key16.7 Algunos Atajos


Grafo prototipo15. Leyendo un Grafo


Grafo, imprimiendo todoC.4 Imprimiendo el Grafo Completo


graph-body-print15.1 La Función graph-body-print


graph-body-print Versión Final.Cambios para la Versión Final


 


H


Historia de LispHistoria de Lisp


 


I


if3.7 La Forma Especial if


‘if-part’ definidaif en más detalle


igual3.11 Revisar


Imprime eje horizontalC.3 La Función print-X-axis


Imprimiendo eje horizontalC.3 La Función print-X-axis


imprimiendo eje XC.3 La Función print-X-axis


imprimiendo eje YC.2 La Función print-Y-axis


Imprimiendo Ejes VerticalesC.2 La Función print-Y-axis


Imprimiendo el grafo enteroC.4 Imprimiendo el Grafo Completo


Imprimiendo el grafo enteroC.4 Imprimiendo el Grafo Completo


Imprimir eje verticalC.2 La Función print-Y-axis


indent-tabs-mode16.6 Indentar Modos de Tabulación


Indentaciń para formatear4.4.3 save-excursion en append-to-buffer


Inicialización de Variable8.5 Inicializando una Variable con defvar


Inicializando una variable8.5 Inicializando una Variable con defvar


insert-buffer5.2 La Definición de insert-buffer


insert-buffer, nueva versión del cuerpo5.2.6 Nuevo Cuerpo para insert-buffer


insert-buffer-substringUn Resumen de append-to-buffer


Insidioso tipo de errorC.4.5 Otro Error … Más Insidioso


Instalar código permanentemente3.5 Instalar Código Permanentemente


Instalar una Definición de Función3.2 Instalar una Definición de Función


Intérprete Lisp, explicada1.2 Ejecutar un Programa


Intérprete Lisp, qué hace1.5 El Intérprete Lisp


Intérprete, Lisp, explicado1.2 Ejecutar un Programa


Intérprete, qué hace1.5 El Intérprete Lisp


interactive3.3 Crear una Función Interactive


interactive, ejemplo de uso5.2.1 La Expresión Interactiva en insert-buffer


 


K


Keep, el tipo de patrón recursivoPatrón Recursivo: keep


kill-appendThe kill-append function


kill-newLa función kill-new


kill-region8.2 kill-region


 


L


lambdaC.4.3 Una Expresión lambda: Anonimicidad Útil


length7.2.1 Encuentra el tamaño de una Lista: length


lengths-list-file14.6 lengths-list-file en Detalle


lengths-list-many-filesDetermina las longitudes de defuns


Lenguajes primitivas CUna Vía acerca de Funciones Primitivas


let3.6 let


Leyendo un grafo15. Leyendo un Grafo


Librería, como término para ‘fichero’4.1 Encontrando Más Información


line-to-top-of-window16.11 Una Extensión Simple: line-to-top-of-window


list-buffers, reasociar16.7 Algunos Atajos


‘lista de argumentos’ definida3.1 La Forma Especial defun


Lista de variables locales, por buffer,16.4 Modo Texto y Auto Relleno


‘lista vacía’ definida1.1.1 Átomos Lisp


Listas en un ordenador9. Cómo las Listas se Implementan


Listas Lisp1.1 Listas Lisp


‘llamada’ definida


load-library16.9 Cargando Ficheros


load-path16.9 Cargando Ficheros


Localización del Punto2.4 Tamaño de Buffer y la Localización del Punto


Localización del punto2.4 Tamaño de Buffer y la Localización del Punto


looking-atEl bucle while hacia adelante


 


M


MaclispHistoria de Lisp


Macro Lisp8.2.2 Macro Lisp


Macro, lisp8.2.2 Macro Lisp


make-stringC.2.2 Construye un Elemento del Eje Y


Manejando el anillo de la muerteB. Manejando el Anillo de la Muerte


Manejando el anillo de la muerteB. Manejando el Anillo de la Muerte


Mapas de teclado16.8 Mapas de teclado


mapcarC.4.4 La Función mapcar


marca3.10 save-excursion


mark-whole-buffer4.3 La Definición de mark-whole-buffer


match-beginningEl bucle while hacia adelante


maxImprimiendo las Columnas de un Grafo


mensaje1.8.5 La función message


mientras11.1 mientras


minImprimiendo las Columnas de un Grafo


mode-line-format16.14 Una Línea Modificada


Modo de autoajuste activado16.4 Modo Texto y Auto Relleno


Modo de selección, automático16.4 Modo Texto y Auto Relleno


Modo Texto activado16.4 Modo Texto y Auto Relleno


Mover frase y párrafo12. Búsquedas de Expresiones Regulares


 


N


‘narrowing’ definido2.4 Tamaño de Buffer y la Localización del Punto


nil3.9 Verdad y Falsedad en Emacs Lisp


nil, historia de palabra2.1 Nombres de Buffer


No aplazar la solución11.3.8 No hay solución pospuesta


Nombres de Símbolos1.4 Nombres de símbolos y Definiciones de Funciones


nreverse14.9.3 Contando definiciones de función


nth7.4 nth


nthcdr7.3 nthcdr


nthcdr8.3 copy-region-as-kill


nthcdr, ejemploLa función kill-new


Número variable de argumentos1.8.3 Número de Variables de Argumentos


nueva versión cuerpo para insert-buffer5.2.6 Nuevo Cuerpo para insert-buffer


number-to-stringC.2.2 Construye un Elemento del Eje Y


 


O


occur16.7 Algunos Atajos


opcional5.3.1 Argumentos Opcionales


Opciones Interactive3.4 Opciones Diferentes para interactive


Opciones para interactive3.4 Opciones Diferentes para interactive


or5.2.4 El or en el Cuerpo


other-buffer2.2 Obteniendo Buffers


 


P


Párrafos, movimiento por12. Búsquedas de Expresiones Regulares


Palabra Clave5.3.1 Argumentos Opcionales


Palabras y símbolos en defun14.1 ¿Qué Contar?


Palabras, contadas recursivamente13.2 Cuenta Palabras Recursivamente


Palabras, duplicadasA. La Función the-the


Partes de Definición Recursiva11.3.2 Las Partes de una Definición Recursiva


Partes de la expresión let3.6.1 Las Partes de una Expresión let


Partes de una Definición Recursiva11.3.2 Las Partes de una Definición Recursiva


Pasando información para funciones1.8 Argumentos


Patrón recursivo: acumularPatrón Recursivo: accumulate


Patrón recursivo: cadaPatrón Recursivo: cada


Patrón recursivo: keepPatrón Recursivo: keep


Patrones Recursivos11.3.6 Patrones Recursivos


Patrones, buscando por12. Búsquedas de Expresiones Regulares


Pegando Texto10. Pegando Texto


pegar10. Pegando Texto


pegarB.2 pegar


Personalizando tu fichero ‘.emacs’16. Tu Fichero ‘.emacs’


Por buffer, lista de variables locales16.4 Modo Texto y Auto Relleno


Practicando la evaluación2. Practicando Evaluación


Preservando punto, marca, y búffer3.10 save-excursion


Primitivas escritas en CUna Vía acerca de Funciones Primitivas


print-elements-of-list11.1.2 Un Ejemplo: print-elements-of-list


print-elements-recursively11.3.3 Recursión con una Lista


print-graph varlistC.1 La Varlist print-graph


print-graph Versión Final.Cambios para la Versión Final


print-X-axisC.3.1 Eje X Marca Tic


print-X-axis-numbered-lineC.3.1 Eje X Marca Tic


print-X-axis-tic-lineC.3.1 Eje X Marca Tic


print-Y-axisC.2.4 La Versión No Demasiado Final de print-Y-axis


progn8.1.4 La Forma Especial progn


Programa, ejecutando uno1.2 Ejecutar un Programa


Propiedades, en el ejemplo del modo línea16.14 Una Línea Modificada


Propiedades, mención de buffer-substring-no-properties6.3 Ejercicio Encogiendo


Prototipo de grafo15. Leyendo un Grafo


punto3.10 save-excursion


‘punto’ definido2.4 Tamaño de Buffer y la Localización del Punto


Punto, marca, preservación de búffer3.10 save-excursion


push, ejemploLa función kill-new


 


R


re-search-forward12.2 La Función re-search-forward


Reasociando teclas16.8 Mapas de teclado


Recuperando Texto10. Pegando Texto


Recuperar Texto10. Pegando Texto


Recursión11.3 Recursión


Recursión sin Defermentos11.3.7 Recursión sin Defermentos


Recursión y bucles11. Bucles y Recursión


Recursivamente contando palabras13.2 Cuenta Palabras Recursivamente


recursive-count-words13.2 Cuenta Palabras Recursivamente


recursive-graph-body-print15.2 La Función recursive-graph-body-print


recursive-lengths-list-many-files14.8 Recursivamente Cuenta Palabras en Diferentes Ficheros


regexp-quoteLa expresión let*


Región, qué es3.10 save-excursion


Repetición (bucles)11. Bucles y Recursión


Repetición para contar palabras13. Contando: Repetición y Regexps


Resumen del Anillo de la Muerte Kill ring10.1 Resumen del Anillo de la Muerte.


reverse14.9.3 Contando definiciones de función


Robots, construyendo11.3.1 Construyendo Robots: Extendiendo la Metáfora


 


S


save-excursion3.10 save-excursion


save-restriction6.1 La Forma Especial save-restriction


se definió ‘evaluate’1.2 Ejecutar un Programa


search-forward8.1.3 La Función search-forward


Selección de modo automático16.4 Modo Texto y Auto Relleno


sentence-end12.1 La Expresión Regular para sentence-end


set1.9.1 Usando set


set-buffer2.3 Cambiando Buffers


set-variable8.5.1 defvar y un asterisco


setcar7.5 setcar


setcdr7.6 setcdr


setcdr, ejemploLa función kill-new


setq1.9.2 Usando setq


Símbolo sin función de error1.7.1 Mensaje de Error para un Símbolo sin una Función


Símbolo sin valor de error1.7.2 Mensaje de Error para un Símbolo sin un Valor


Símbolos como una Caja con Cajones9.1 Símbolos como una Caja con Cajones


simplified-beginning-of-buffer4.2 Una Definición Simplificada beginning-of-buffer


Sin posponer la solución11.3.8 No hay solución pospuesta


Solución sin defermento11.3.8 No hay solución pospuesta


sort14.9.1 Ordenando Listas


switch-to-buffer2.3 Cambiando Buffers


 


T


tabla TAGS, especificando4.1 Encontrando Más Información


Tabuladores, previniendo16.6 Indentar Modos de Tabulación


Tamaño del búffer2.4 Tamaño de Buffer y la Localización del Punto


Tamaño del Búffer2.4 Tamaño de Buffer y la Localización del Punto


Teniendo un búffer2.2 Obteniendo Buffers


Texto entre comillas1.1.1 Átomos Lisp


the-theA. La Función the-the


‘then-part’ definidaif en más detalle


Tipo incorrecto de argumento1.8.4 Usando el Tipo Incorrecto de Objeto como un Argumento


Tipos de datos1.8.1 Tipos de Argumentos de Datos


Tipos de Datos1.8.1 Tipos de Argumentos de Datos


top-of-ranges14.9.3 Contando definiciones de función


triangle-bugged17.1 depurar


triangle-recursively11.3.4 Recursión en Lugar de un Contador


 


V


‘valor devuelto’ explicadoCómo el Intérprete Actúa


Variable de Ejemplo, fill-columnfill-column, un Ejemplo de Variable


‘variable global’ definidaDeterminando el Elemento


‘variable local’ definidalet Evita Confusiones


Variable, asignando valor1.9 Configurando el Valor de una Variable


Variable, ejemplo de, fill-columnfill-column, un Ejemplo de Variable


‘variable, global’, definidaDeterminando el Elemento


‘variable, local’, definidalet Evita Confusiones


Variables1.7 Variables


Variables let No Inicializadas3.6.3 Variables No Inicializadas en un Sentencia let


Variables let no inicializadas3.6.3 Variables No Inicializadas en un Sentencia let


‘varlist’ definida3.6.1 Las Partes de una Expresión let


Verdad y mentira en Emacs Lisp3.9 Verdad y Falsedad en Emacs Lisp


Versión de Emacs, eligiendo16.11 Una Extensión Simple: line-to-top-of-window


Versión de Emacs, eligiendo16.11 Una Extensión Simple: line-to-top-of-window


 


W


what-line6.2 what-line


 


X


X-axis-elementC.3.1 Eje X Marca Tic


 


Y


Y-axis-columnC.2.3 Crea un Eje de la Columna Y


Y-axis-column Versión Final.Cambios para la Versión Final


Y-axis-label-spacingC.2.1 Viaje Lateral: Computa un Recuerdo


Y-axis-ticC.2.2 Construye un Elemento del Eje Y


yank-popB.3 yank-pop


 


Z


zap-to-char8.1 zap-to-char


zeropEl cuerpo de current-kill


 




Saltar a:   %
   
(
   
*
   
/
   
<
   
>
   


A
   
B
   
C
   
D
   
E
   
F
   
G
   
H
   
I
   
K
   
L
   
M
   
N
   
O
   
P
   
R
   
S
   
T
   
V
   
W
   
X
   
Y
   
Z
   










[ < ]
[ > ]
   
[ << ]
[ Subir ]
[ >> ]
   
   
   
   
[Arriba]
[Índice general]
[Índice]
[ ? ]




Acerca del Autor



Robert J. Chassell ha trabajado con GNU Emacs desde 1985. Él
escribe, edita y enseña Emacs y Emacs Lisp, y habla alrededor del
mundo acerca de la libertad del software. Chassell estuvo fué un
Director fundador y Tesorero de la Fundación por el Software Libre,
Inc. Él se graduó la Universidad de Cambridge, en Inglaterra. Él
tiene un interés contínuo en historia económica y social y vuela
su propio aeroplano











[Arriba]
[Índice general]
[Índice]
[ ? ]



Notas el pie


(1)


Los apóstrofes simples
o las marcas de citas son una abreviación para la función
quote; tu no necesitas pensar acerca de funciones ahora; las
funciones son definidaas en Generar un Mensaje de Error.

(2)


Es
curioso trazar la ruta por la que la palabra ‘argumento’ viene para
tener dos significados diferentes, uno en matemáticas y el otro en
el inglés de cada día. De acuerdo al Oxford
English Dictionary, la palabra deriva del Latín para
‘clarificar’, de este modo significa, por un hilo de
derivación, viene a significar ‘asertir de una manera contra otro
que puede crear un contador de aserciones’, que lidera el significado
de la palabra como una disputa. (Nótese aquí que la
palabra Inglés tiene dos definiciones diferentes adjuntas al mismo
tiempo. En contraste, en Emacs Lisp, un símbolo no puede
tener dos definiciones de funciones diferentes al mismo tiempo.)

(3)


(quote
hello) es una expresión de la abreviación 'hello.

(4)


Actualmente,
puede usar %s para imprimir un número. Eso es no
específico. %d imprime solo la parte de un
número a la izquierda de un punto decimal, y no cualquier cosa que
no es un número.

(5)


Actualmente, por defecto, si el búffer desde
el que tu has cambiado es visible para tí en otra
ventana, other-buffer elegirá el búffer más reciente que
no puedes ver; esto es algo pequeño que he olvidado.

(6)


O
incluso, para cambiar, solo se necesita pulsar RET si el buffer
por defecto era ‘*scratch*’, o si era diferente, entonces se
puede escribir solo parte del nombre, tal como *sc, luego
presiona la tecla TAB para causar expandir al nombre completo, y
entonces escribe la tecla RET

(7)


Recuerda, esta expresión te permite cambiar a
tus búffers más recientes y otros buffers que no puedes ver. Si
realmente quieres ir a tus búffers seleccionados más
recientemente, se necesita evaluar la siguiente expresión más
compleja: 
 
 (switch-to-buffer (other-buffer
(current-buffer))) 


En este caso, el primer argumento
a other-buffer cuenta de que búffer salir — el actual — y
el segundo argumento cuenta al other-buffer es OK para cambiar
a un búffer visible. En uso regular, switch-to-buffer toma a
una ventana invisible desde usarías C-x o
(other-window) para ir a otro búffer visible.



En los ejemplos de programación en secciones posteriores de este
documento, tu verás la función set-buffer con más con
frecuencia que switch-to-buffer. Esto es porque a diferencia
entre los programas de ordenador y humanos: los humanos tienen ojos y
esperan ver el búffer en el que ellos están trabajando en sus
terminales de ordenador. Esto es así de obvio, casi va
sin decirlo. Sin embargo, los programas no tienen ojos. Cuando un
programa de ordenador trabaja en un búffer, que búffer no
necesitan ser visibles en la pantalla.



switch-to-buffer está diseñado para humanos y hace dos
cosas diferentes: eso cambia el búffer para el que la atención de
Emacs está dirigida; y cambia el búffer mostrada en la ventana al
nuevo búffer. set-buffer, por otro lado, hace solo una cosa:
eso cambia la atención del programa del ordenador a un búffer. El
búffer en la pantalla permanece sin cambios (de acuerdo, normalmente
no ocurre nada hasta que el comando finaliza ejecutándose).




También, nosotros hemos introducido otro término de jerga, la
palabra llamada. Cuando tu evalúas una lista en el que el
primer símbolo es una función, tu estás llamando
esta función. El uso del término viene desde la noción de la
función como una entidad que puede hacer alguna cosa para
tí si tu ‘llamas’ — a liderar es una entidad quien
puede arreglar una falta si tu le llamas a él o ella.

(8)


De
acuerdo a Jared Diamond en Guns, Germs, y Steel, “…
cebras llega a ser peligrosamente imposible como ellos crecen viejos”
pero el clamor aquí son que ellos no llegan a ser fieros
como un tigre. (1997, W. W. Norton and Co., ISBN 0-393-03894-2, page
171)

(9)


Actualmente,
se puede cons un elemento para un átomo para producir a para
punteado. Los pares punteados no se discuten aquí; ver
(elisp)Notación de Pares Punteados sección ‘Notación de Para Punteado’ en El Manual de Referencia de GNU Emacs Lisp.

(10)


Más precisamente, y requiriendo conocimiento
más experto para comprender, los dos enteros son del tipo
‘Lisp_Object’, que puede tambiés ser una unión C en vez de un tipo
de entero.

(11)


Se puede escribir funciones recursivas para ser
frugal o basura de mente o recursos de ordenador; como eso ocurre, los
métodos la gente encuentra fáciles — que son frugales de
‘recursos mentales’ — algunas veces usan recursos de ordenador
considerables. Emacs fué diseñado para ejecutarse en máquina que
ahora se consideran limitada y sus configuraciones por defecto son
conservadoras. Se puede querer incrementar los valores de
max-specdl-size y max-lisp-eval-depth. En mi fichero
‘.emacs’, yo los asigno a 15 o 30 veces su valor por defecto.

(12)


La jerga es medianamente confusa:
triangle-recursive-helper usa un proceso que es iterativo en un
procedimiento que es recursivo. El proceso se llama iterativo porque
el ordenador necesita solo grabar los tres valores, suma,
contador, y número: el procedimiento es recursivo
porque la función ‘llama a sí mismo’. Por otro lado,
ambos el proceso y el procedimiento usado por
triangle-recursively son llamados recursivos. La palabra
‘recursivo’ tiene diferentes significados en los dos contextos.

(13)


Tu puedes también añadir ‘.el’ para
‘~/.emacs’ y llama a un fichero ‘~/.emacs’. En el pasado,
fué prohibido escribir los atajos de teclado extra que el nombre
‘~/.emacs.el’ requiere, pero ahora puedes. El nuevo formato es
consistente con las conveniciones de nombre del fichero Emacs Lisp; el
viejo formato guarda la escritura.

(14)


Cuando se empieza las instancias de
Emacs que no cargan mi fichero ‘.emacs’ o cualquier fichero,
también se puede deshabilitar la ocultación: 
 
 emacs
-q --no-site-file -eval '(blink-cursor-mode nil)' O ahora,
usando un conjunto más sofisticado de opciones, emacs -Q - D @end
smallexample



(15)


también se ejecutan gestores de ventanas más
modernos, tales como Enlightenment, Gnome, o KDE; en estos casos, con
frecuencia se especifica una imagen en vez de un color plano.






[Arriba]
[Índice general]
[Índice]
[ ? ]



Índice General













[Arriba]
[Índice general]
[Índice]
[ ? ]



Resumen del Contenido












[Arriba]
[Índice general]
[Índice]
[ ? ]



Acerca de este documento



  Este documento ha sido generado por David el el 16 julio 2014 utilizando texi2html 1.82.




  Los botones de los paneles de navegación tienen el significado siguiente:




  

     Botón 
     Nombre 
     Ir a 
     Desde 1.2.3 ir a
  

  

     [ < ] 
    Atrás
    Sección anterior en orden de lectura
    1.2.2
  

  

     [ > ] 
    Adelante
    Sección siguiente en orden de lectura
    1.2.4
  

  

     [ << ] 
    Retroceso rápido
    Inicio de este capítulo o capítulo anterior
    1
  

  

     [ Subir ] 
    Subir
    Subir sección
    1.2
  

  

     [ >> ] 
    Avance rápido
    Capítulo siguiente
    2
  

  

     [Arriba] 
    Arriba
    Portada del documento
       
  

  

     [Índice general] 
    Índice general
    Índice general
       
  

  

     [Índice] 
    Índice
    Índice
       
  

  

     [ ? ] 
    Acerca de
    Acerca de (página de ayuda)
       
  






  donde el  Ejemplo  supone que la posición actual está en la  Sub-subsección uno-dos-tres  de un documento de la estructura siguiente:









 
  Este documento ha sido generado por David el el 16 julio 2014 utilizando texi2html 1.82.