FUNNY SOMETHING OR OTHER

Para obtener algo en una computadora, necesita una forma de introducir texto en los archivos, y una manera de cambiar el texto que ya está en los archivos. Un editor es un programa para este tipo de tareas. emacs es uno de los editores más populares, en parte porque es muy fácil para un principiante hacer trabajos con él. (El editor de Unix clásico, el vi, se trata en el Apéndice A).

Para aprender emacs, tiene que encontrar un archivo de texto (letras, números, etc.) cópielo a su directorio de usuario 1 (no queremos modificar el archivo original, si éste contiene información importante), y luego llame a Emacs con el archivo:

(Por supuesto, si decide copiar /etc/rc, /etc/inittab, o cualquier otro archivo, sustituya ese nombre de archivo por LEAME. Por ejemplo, si "cp /etc/rc ~/rc" , entonces "emacs rc").

"Llamar" a Emacs puede tener efectos diferentes dependiendo en dónde lo haga. Desde una consola que muestra sólo caracteres de texto Emacs se apoderará de toda la consola. Si lo llama desde X, Emacs abrirá su propia ventana. Asumiré que lo está haciendo desde una consola de texto, pero todo sucede de la misma manera en la versión de X, lógicamente simplemente sustituya la palabra "ventana" en los lugares en donde lea "pantalla". ¡Además, recuerde que debe mover el puntero del ratón a la ventana de Emacs para escribir!

Su pantalla (o ventana, si está usando X) debería parecerse a la Figura 8.1. La mayor parte de la pantalla contiene su documento de texto, pero las dos últimas líneas son especialmente interesantes si está tratando de aprender Emacs. La penúltima línea (la que tiene una cadena larga de guiones) se denomina línea de modo ("mode line" en inglés).

_____________________________________________

1 Por ejemplo, "cp /usr/src/linux/LEAME ./LEAME"

En mi línea de modo, ve "Top". Debería decir "All", y puede haber otras pequeñas diferencias.

(A muchas personas les aparece la hora actual en la línea de modo). La línea inmediatamente inferior a la línea de modo se denomina minibuffer, o a veces el área de eco. Emacs usa el minibuffer para enviar mensajes al usuario, y ocasionalmente cuando es necesario, para leer información que introduce el usuario. De hecho, ahora mismo Emacs le está diciendo "Para obtener información acerca del Proyecto GNU y sus objetivos, teclee C-h C-p." (sólo que en inglés). Ignórelo por ahora; no vamos a usar mucho el minibuffer por un tiempo.

Antes de realizar cualquier cambio en el texto del archivo, necesita aprender cómo moverse. El cursor deberá estar al principio del archivo, en la esquina superior izquierda de la pantalla.

Para avanzar, presione |_C-f_| (reteniendo la tecla |_Control_| mientras presiona "f", para "forward" (avanzar). Avanzará un carácter cada vez, y si retiene ambas teclas, la repetición automática de teclas de su sistema deberá surtir efecto en medio segundo aproximadamente. Notará como, cuando llega al fin de la línea, el cursor automáticamente se mueve a la próxima línea. |_C-b_| (para "backward" (retroceder) tiene el comportamiento opuesto. Y, ya que estamos en ello, |_C-n_| y ||_C-p_|| le llevan a las líneas siguiente y anterior, respectivamente. 2

Usar las teclas de control es comúnmente la manera más rápida de moverse cuando está editando.

El objetivo de Emacs es mantener sus manos sobre las teclas alfa-numéricas del teclado, donde se realiza la mayoría del trabajo. Sin embargo, si quiere, las teclas de movimiento deberán funcionar también.

De hecho, cuando usa X, debería ser capaz de ubicar el puntero del ratón y hacer "click" con el botón izquierdo para mover el cursor donde quiera. Sin embargo, esto es muy lento, ¡tiene que mover la mano hasta el ratón! La mayoría de la gente que usa Emacs usa principalmente el teclado para moverse por el texto.

_____________________________________________

2 En caso de que aún no lo haya notado, muchos de los comandos de movimiento de emacs consisten en combinar |_Control_| con una única letra mnemotécnica.

Use ||_C-p_|| y |_C-b_| para ir a la esquina superior izquierda. Ahora mantenga |_C-b_| un poco más.

Debería oír un sonido molesto de campana, y ver el mensaje "Beginning of buffer" (Principio del buffer) que aparece en el minibuffer. En este punto se puede preguntar, "¿Pero qué es un buffer?". Cuando Emacs trabaja sobre un archivo, no trabaja realmente sobre el archivo en sí. En vez de eso, copia los contenidos del archivo en un área de trabajo especial de Emacs llamada buffer, donde puede modificar el contenido. Cuando ha acabado de trabajar, debe decirle a Emacs que guarde los buffers, en otras palabras, que escriba el contenido de los buffers en el archivo correspondiente.

Hasta que haga esto, el archivo permanece sin cambiar, y el contenido de los buffers existe únicamente dentro de Emacs.

Con esto en mente, prepárese a insertar su primer carácter en el buffer. Hasta ahora, todo lo que hemos hecho ha sido "no destructivo", este es un gran momento. Puede escoger cualquier carácter que quiera, pero si quiere hacer esto con estilo, yo sugiero usar una bonita y sólida, "X" mayúscula.

Mientras lo teclea, eche un vistazo al principio de la línea de modo al pie de la pantalla. Cuando cambia los buffer de modo que sus contenidos no sean iguales que los del archivo sobre el disco, Emacs muestra dos asteriscos a principios de la línea de modo, para hacerle saber que el buffer ha sido modificado:  

Estos dos asteriscos se muestran tan pronto como modifica el buffer, y permanecen visibles hasta que guarde el buffer. Puede guardar los buffer muchas veces durante una sesión de edición, el comando para hacerlo es simplemente |_C-x_C-s_| (presione |_Control_| y pulse "x" y "s" mientras la mantiene apretada, ¡probablemente ya se lo imaginó!). Es deliberadamente fácil de escribir, porque lo mejor es salvar sus buffers al principio y frecuentemente.

Ahora voy a enumerar más comandos, además de los que ya ha aprendido, y los puede practicar del modo que prefiera. Yo sugiero familiarizarse con ellos antes de proseguir:

Si está interesado en editar unos archivos rápidamente, un usuario de X no tiene que ir mucho más allá de los menús en la parte superior de la pantalla. Estos menús no están disponibles en el modo texto.

Cuando ejecute por primera vez Emacs, habrá cuatro menús en la parte superior de la pantalla: Buffers, File, Edit, y Help. Para usar un menú, simplemente mueva el puntero del ratón sobre el nombre (como File, haga click y retenga el botón izquierdo). Entonces, mueva el puntero a la acción que quiere y libere el botón del ratón. Si cambia de idea, retire el puntero del ratón del menú y libere el botón.

El menú Buffers enumera los diferentes archivos que han sido editados en esta instancia de Emacs.

El menú Files muestra un grupo de comandos para cargar y guardar archivos, muchos de ellos se describirán más adelante. El menú Edit muestra algunos comandos para editar un buffer, y el menú Help debería dar la documentación en línea.

Notará que las equivalencias del teclado se enumeran junto a las opciones del menú. Puesto que, a largo plazo, éstas serán más rápidas, podría quererlas aprender. También, para bien o para mal, la mayoría de la funcionalidad de Emacs está únicamente disponible mediante el teclado, así que puede que le interese leer el resto de este capítulo.

Emacs puede trabajar sobre más de un de archivo a la vez. De hecho, el único límite sobre cuantos buffers puede contener Emacs es la cantidad real de memoria disponible en la máquina. El comando para traer un nuevo archivo a un buffer de Emacs es |_C-x_C-f_|. Cuando lo teclee, se le pedirá un nombre de archivo en el minibuffer:

La sintaxis, aquí, es la misma que la usada para especificar archivos desde la línea de comandos; las barras representan subdirectorios, ~ es su directorio de usuario. También consigue terminación automática de nombre de archivo, significa que si ha escrito suficiente de un nombre de archivo en la línea de comandos para identificar el archivo singularmente, puede simplemente presionar |_Tab_| para completarlo (o para ver las terminaciones posibles, si hay más de una). ||_Espacio_|| también tiene un papel en la terminación automática de nombres de ficheros en el minibuffer, parecido a |_Tab_|, pero dejaré que experimente para que averigüe cómo difieren las dos. Una vez que tiene el nombre completo en el minibuffer, presione |_Intro_|, y Emacs creará un buffer mostrando el archivo. En Emacs, este proceso es conocido como encontrar un archivo. Siga adelante y busque ahora algún otro archivo de texto sin importancia y tráigalo a Emacs (haga esto desde nuestro buffer original algun_archivo.txt). Ahora tiene un nuevo buffer; Supondré que se llama otro_archivo.txt, ya que no puedo ver su línea de modo.

Su buffer original parece haber desaparecido (probablemente) se pregunta dónde fue. Está todavía dentro de Emacs, y puede volver a él con |_C-x_b_|. Cuando teclee esto, verá que en el minibuffer le pide el nombre un buffer al que cambiar, y nombra uno por defecto. El buffer por defecto lo consigue sólo con presionar |_Intro_| en la línea de comandos, sin escribir un nombre de buffer. El buffer por defecto al que cambiar, es siempre el más recientemente usado, para que cuando esté haciendo mucho trabajo entre dos buffers, |_C-x_b_| tenga por defecto el "otro" buffer (salvándole de tener que escribir el nombre del buffer). Incluso si el buffer por defecto es el que quiere, debería probar a teclear su nombre de todos modos.

Note que consigue el mismo tipo de terminación automática que obtuvo al buscar un archivo: al pulsar |_Tab_| completa todo lo que puede del nombre de un buffer y así sucesivamente. Cada vez que se le pida algo en el minibuffer, es una buena idea ver si Emacs hace terminación automática.

Aprovechando la terminación automática cuando se le ofrezca, ahorrará teclear mucho. Emacs comúnmente hace la terminación automática cuando elige un elemento de alguna lista predefinida.

Todo lo que ha aprendido para moverse y editar texto en el primer buffer se aplica a los nuevos. Siga adelante y cambie algún texto en el nuevo buffer, pero no lo guarde (es decir, no teclee |_C-x_C-s_|).

Déjeme asumir que quiere desechar los cambios sin guardarlos en el archivo. El comando para esto es C-x k, que "mata" (kill) el buffer. Tecléelo ahora. Primero se le preguntará qué buffer matar, pero por defecto es el buffer actual, y casi siempre es el que se quiere matar, simplemente presione |_Intro_|. Entonces le preguntará si realmente quiere matar el buffer, Emacs siempre controla antes de matar un buffer que tiene cambios sin salvar. Simplemente escriba "yes" (sí) y presione |_Intro_|, si quiere matarlo.

Siga adelante y practique cargar archivos, modificarlos, guardarlos, y matar sus buffers. Por supuesto, cerciórese de no modificar ningún archivo de sistema importante de una forma que cause problemas 3, pero trate de tener por lo menos cinco buffers abiertos al mismo tiempo, para que se pueda dar el gusto de moverse entre ellos.

Cuando haya hecho su trabajo en Emacs, asegúrese de que se guarden todos los buffers que deben guardarse, y salga de Emacs con |_C-x_C-c_|.

A veces |_C-x_C-c_| le hará una pregunta o dos en el minibuffer antes de dejarle salir, no se alarme, simplemente conteste en las maneras obvias. Si piensa que podría volver a Emacs luego, no use |_C-x_C-c_|; use |_C-z_|, que suspenderá Emacs. Puede volver luego con el comando "fg" del shell.

Esto es más eficiente que detener a Emacs y comenzar varias veces, especialmente si tiene que editar los mismos archivos nuevamente.

Bajo X, presionar |_C-z_| reducirá a icono la ventana. Mire la sección sobre minimizar en el Capitulo 5. Esto le da dos formas de minimizar Emacs, la manera normal que ofrece el gestor de ventanas, y |_C-z_|. Recuerde, cuando minimice, un simple "fg" no traerá la ventana anterior, tendrá que usar el gestor de ventanas.

_____________________________________________

3 De cualquier manera, si no es el usuario "root" de la máquina, no debería ser capaz de dañar el sistema, pero tenga cuidado igualmente.

Ha aprendido ya sobre una "tecla modificadora" en Emacs, la tecla |_Control_|. Hay una segunda, llamada la tecla Meta, que se usa casi tan frecuentemente. Sin embargo, no todos los teclados tienen su tecla Meta en el mismo lugar, y algunos ni siquiera la tienen. Lo primero que necesita hacer es encontrar dónde se encuentra su tecla Meta. Es probable que las teclas |_Alt_| de su teclado sean también teclas Meta, si usa un PC IBM o algún otro teclado que tenga una tecla |_Alt_|.

La forma de probar esto es mantener presionada una tecla que crea que puede ser una tecla Meta y teclear "x". Si ve que un pequeño prompt aparece en el minibuffer (como esto: |_M-x_|), entonces la ha encontrado. Para librarse del prompt y regresar al buffer de Emacs, teclee ||_C-g_||.

Si no consigue un prompt, entonces todavía queda una solución. Puede usar la tecla ||_Escape_|| como una tecla Meta. Pero en vez de mantenerla pulsada mientras teclea la próxima letra, tiene que pulsarla y soltarla rápidamente, y entonces teclee la letra. Este método funcionará tenga o no una tecla Meta verdadera, también es la manera más segura para hacerlo. Intente ahora pulsar ligeramente ||_Escape_|| y entonces teclee "x". Debería conseguir otra vez ese pequeño prompt.

Simplemente use ||_C-g_|| para salir. ||_C-g_|| es la manera general en Emacs para salir de algún lugar donde no quiere estar. Los fastidiosos y comunes pitidos son para hacerle saber que ha interrumpido algo, pero está bien, porque es lo que quería hacer cuando tecleó ||_C-g_||4

La notación |_M-x_| es análoga a |_C-x_| (ponga cualquier carácter en el lugar de la "x"). Si ha encontrado una verdadera tecla Meta, use ésta, de otra manera simplemente use la tecla ||_Escape_||. Yo escribiré simplemente |_M-x_| y ud. tendrá que usar su propia tecla Meta.

Emacs, como cualquier buen editor, le permite cortar y pegar bloques de texto. A fin de hacer esto, necesita una forma de definir el comienzo y fin del bloque. En Emacs, se hace esto estableciendo dos ubicaciones en el buffer, conocidas como marca y puntero. Para colocar la marca, vaya al lugar donde quiere que comience el bloque y teclee |_C-SPC_| ("SPC" significa ||_Espacio_||, por supuesto).

Debería ver el mensaje "Mark set" (Marca establecida) que aparece en el minibuffer5. Ahora la marca ha sido establecida en ese lugar. No habrá ningún indicador especial destacando este hecho, pero Ud. sabe dónde la ha puesto, y eso es lo que importa.

¿Y qué hay del puntero? Bien, resulta que ha colocado un puntero cada vez que ha movido el cursor, porque "puntero" simplemente se refiere a su ubicación actual en el buffer. En términos formales, el puntero es el punto donde se insertará el texto si escribe algo. Al colocar la marca, y luego moverse al final del bloque, ha definido un bloque de texto. Este bloque es conocido como la región. La región siempre significa el área entre la marca y el puntero.

El sólo hecho de definir la región no la deja disponible para pegar. Tiene que decirle a Emacs que lo copie para poder ser capaz de pegarlo. Para copiar la región, asegúrese de que la marca y el puntero están correctamente establecidos, y teclee |_M-w_|. Ahora ha sido grabada por Emacs. Para pegarlo en alguna otra parte, simplemente vaya allí y teclee ||C-y_||. Esto es conocido como tirar el texto en el buffer.

______________________________________________

4 Ocasionalmente, un C-g no es suficiente para persuadir a emacs que realmente quiere interrumpir lo que hace. Simplemente insista, y normalmente Emacs volverá a un modo más cuerdo.

5 Sobre algunos terminales, |_C-SPC_| no funciona. Para estas máquinas, debe usar |_C-@_|.

Si quiere mover el texto de la región a alguna otra parte, teclee |_C-w_| en vez de |_M-w_| Esto matará la región, todo el texto dentro de ella desaparecerá. De hecho, se ha guardado del mismo modo que si hubiera usado |_M-w_|. Puede tirar de nuevo con ||_C-y_||, como siempre. El lugar donde emacs guarda todo este texto es conocido como el círculo de muerte. Algunos editores lo llaman el "porta papeles" o el "buffer de pegado".

Existe otra manera para cortar y pegar: cuando usa |_C-k_| para matar hasta el final de una línea, el texto matado se guarda en el círculo de muerte. Si mata más de una línea seguida, se guardarán todas juntas en el círculo de muerte, para que la próxima tirada pegue todas las líneas al mismo tiempo. Por ello, casi siempre es más rápido usar repetidas veces |_C-k_| para matar algún texto, que establecer la marca y el puntero y usar |_C-w_|. Sin embargo, de una u otra manera funcionará. Es realmente una cuestión de preferencia personal cómo lo hace.

Hay varias maneras para buscar texto en Emacs. Muchas son más bien complejas, y no merece la pena tratarlas aquí. La más fácil y la más entretenida es usar isearch.

"Isearch" se refiere a "incremental search" (búsqueda incremental). Supongamos que quiere buscar la cadena "tábano" en el siguiente buffer:

Debería moverse al comienzo del buffer, o por lo menos a algún punto que sabe que está antes de la primera aparición de la palabra, "tábano", y teclear |_C-s_|. Eso le pondrá en el modo de búsqueda isearch. Ahora comience a escribir la palabra que está buscando, "tábano". Pero tan pronto como escribe la "t", ve que Emacs ha saltado a la primera aparición de "t" en el buffer. Si la cita de arriba es todo el contenido del buffer, entonces la primera "t" es de la palabra "temeroso". Ahora escriba la "á" de "tábano", y Emacs saltará sobre "tácito", que contiene la primer ocurrencia de "tá". Y finalmente, "b" consigue "tábano", sin haber tenido que escribir la palabra entera.

Lo que hace en una isearch es definir una cadena para buscarla. Cada vez que agrega un carácter al final de la cadena, el número de posibles cadenas se reduce, hasta que haya escrito lo suficiente para definir la cadena singularmente. Una vez que ha encontrado la palabra, puede salir de la búsqueda con |_Intro_| o cualquiera de los comandos normales de movimiento. Si piensa que la cadena que buscas esta atrás en el buffer, entonces debería usar |_C-r_|, que hace isearch hacia atrás.

Si encuentra una palabra, pero no es la que buscaba, entonces presione |_C-s_| nuevamente mientras todavía esté en la búsqueda. Esto le moverá hasta la próxima palabra coincidente, cada vez que lo haga. Si no existe una próxima palabra, dirá que la búsqueda fracasó, pero si presiona |_C-s_| nuevamente en este punto, la búsqueda volverá a comenzar desde el principio del buffer. Se puede decir lo opuesto de |_C-r_| comienza al final del buffer.

Intente introducir un buffer de texto en inglés y haga un isearch para la cadena "the". Primero teclee todos los "the" que quiera y luego use |_C-s_| para ir a todas las apariciones. Note que también aparecerán palabras como " them", dado que también contiene la subcadena "the". Para buscar un único "the", deberá agregar un espacio al final de la cadena de búsqueda. Puede agregar nuevos caracteres a la cadena en cualquier punto de la búsqueda, después tiene que presionar |_C-s_| repetidamente para encontrar las próximas palabras coincidentes. Puede usar también la |_Retroceso_| o ||_Supr_|| para quitar caracteres de la cadena en cualquier punto de la búsqueda, y presionando |_Intro_| sale de la búsqueda, dejándole en la última coincidencia.

Emacs también permite reemplazar todas las apariciones de una cadena con alguna nueva cadena, esto es conocido como query-replace (preguntar-reemplazar). Para invocarlo, teclee query-replace y |_Intro_|.

Como se hace terminación automática sobre el nombre del comando, una vez que has escrito "query-re", puede simplemente presionar |_Tab_| para terminarlo. Digamos que desea reemplazar todas las ocurrencias de "tábano" por "mosca". En el prompt "Query replace: " (preguntar-reemplazar), escriba "tábano", y presione |_Intro_|. Entonces aparecerá el prompt nuevamente, y deberá introducir "mosca". Entonces Emacs recorrerá el buffer, parando a cada aparición de la palabra "tábano", y preguntando si quiere reemplazarla. Simplemente presione en cada instancia " y" o "n", por "Yes" o "No', hasta que termine. Si no entiende esto mientras lo lee, pruébelo.

Realmente, todas estas teclas ligadas que ha aprendido son los atajos a funciones de Emacs. Por ejemplo, ||_C-p_|| es una manera abreviada de decirle a Emacs que ejecute la función interna previous-line (línea_previa). Sin embargo, todas estas funciones internas pueden ser llamadas por el nombre, usando |_M-x_|. Si olvida que previous-line está ligado a ||C-p_||, puede escribir simplemente |_M-x_| previous-line |_Intro_|, y se moverá una línea hacia arriba. Pruebe esto ahora, para que comprenda como |_M-x_| previous-line y ||_C-p_ || son realmente la misma cosa.

El diseñador de Emacs comenzó desde la base hacia arriba, primero definió un lote completo de funciones internas, y entonces les asoció o ligó ciertas teclas a las más comúnmente usadas. A veces es más fácil llamar a una función explícitamente con |_M-x_| que recordar a qué tecla está ligada.

La función query-replace, por ejemplo, está ligada a ||_M-%_|| en algunas versiones de Emacs. Pero ¿quién puede recordar tan rara combinación? A menos que use query-replace muy frecuentemente, es más fácil simplemente llamarla con |_M-x_|.

La mayoría de las teclas que pulsa son letras, cuya función es ser insertadas en el texto del buffer. Cada una de esas teclas está ligada a la función self-insert-command, que no hace nada más que insertar la letra en el buffer. Las combinaciones que usan la tecla |_Control_| con una letra generalmente están ligadas a funciones que hacen otras cosas, como mover el cursor. Por ejemplo, |_C-v_| está ligada a una función llamada scroll-up (avanzar página), que mueve el buffer una pantalla hacia arriba (lo que quiere decir que su posición en el buffer se mueve hacia abajo, por supuesto).

Si alguna vez quisiera realmente insertar un carácter de Control en el buffer, entonces, ¿cómo lo haría? Después de todo, los caracteres de Control son caracteres ASCII, aunque rara vez usados, y puede querer tenerlos en un archivo. Hay una manera para_impedir_que los caracteres de Control sean interpretados como comandos por Emacs. La tecla ||_C-q_||6 está ligada a una función especial llamada quoted-insert (insertar lo citado). Todo lo que quoted-insert hace es leer la próxima tecla e insertarla literalmente en el buffer, sin tratar de interpretarla como un comando. Así es cómo puede poner los caracteres de Control en sus archivos usando Emacs. ¡Naturalmente, la manera de insertar un C-q es presionar ||C-q_|| dos veces!

Emacs también tiene muchas funciones que no están ligadas a ninguna tecla. Por ejemplo, si escribe un mensaje largo, y no quiere tener que presionar |_Intro_| al final de cada línea. Puede hacer que emacs lo haga por Ud. (de hecho puede hacer que Emacs haga cualquier cosa por Ud.), el comando para hacerlo se llama auto-fill-mode (modo de auto llenado, pero no está ligado a ninguna tecla por defecto. A fin de invocar este comando, debe escribir "M-x auto-fill-mode".

"M-x" es la tecla usada para llamar a funciones por el nombre. Podría usarlo para llamar a funciones como next-line y previous-line, pero eso sería muy ineficaz, ya que esas funciones están ligadas a |_C-n_| y ||_C-p_||.

A propósito, si mira su línea de modo después de invocar auto-fill-mode, notará que la palabra "Fill" se ha agregado al lado derecho. Mientras esté allí, Emacs llenará (rellenará) el texto automáticamente. Puede desactivarlo escribiendo "M-x auto-fill-mode" nuevamente, es un comando de palanca.

La incomodidad de escribir largos nombres de función en el minibuffer disminuye porque Emacs hace terminación automática en los nombres de funciones de la misma manera que lo hace en los nombres de archivo. Por lo tanto, rara vez debería encontrarse escribiendo el nombre entero de la función letra a letra. Si no está totalmente seguro de si puede o no usar la terminación automática, simplemente presione |_Tab_|. No puede hacer daño: lo peor que puede suceder es que consiga un carácter Tab, y si es afortunado, resultará que puede usar la terminación automática.

Emacs tiene extensas facilidades de ayuda, tan extensas de hecho, que sólo podemos comentarlas un poco aquí. A las facilidades de ayuda más básicas se accede tecleando |_C-h_| y luego una única letra. Por ejemplo, |_C-h_k_| muestra la ayuda sobre una tecla (le pide que presiones una tecla, y entonces le dice lo que esa tecla hace). |_C-h_t_| abre un breve manual sobre Emacs. Más importante aún, |_C-h_C-h_C-h_| le da ayuda sobre la ayuda, para decirle que está disponible una vez que ha tecleado |_C-h_| por primera vez. Si sabe el nombre de una función de Emacs (save-buffer (grabar el buffer), por ejemplo), pero no puede recordar cuál es la combinación de teclas a la que está ligada, use |_C-h_w_|, para "where-is" (dónde está), y escriba el nombre de la función. O, si quiere conocer qué hace una función con detalle, use |_C-h_f_|, que preguntará por un nombre de función.

______________________________________________

6 Llamamos a C-q una "tecla", aunque se produce manteniendo presionada la tecla Controly presionando "q", porque es un único carácter ASCII.

Recuerde, que como Emacs hace terminación automática del nombre de la función, realmente no tiene que estar seguro de cómo se llama para pedir ayuda sobre ella. Si piensa que puedes adivinar la palabra con la que podría comenzar, teclee ésa y presione |_Tab_ |para ver si se completa. Si no, vuelva atrás e intente otra cosa. Lo mismo ocurre con los nombres de archivo: aún cuando no pueda recordar del todo como nombró cierto archivo al que no ha accedido en tres meses, puede probar y usar la terminación automática para averiguar si está en lo cierto. Usa la terminación automática como una forma de preguntar, y no sólo como una manera de teclear menos.

Hay otros caracteres que puede pulsar después de |_C-h_|, y con cada uno consigue ayuda de una manera diferente. Los que usará más frecuentemente son |_C-h_k_|, |_C-h_w_|, y |_C-h_f_|. Una vez que esté más familiarizado con Emacs, otra para probar es |_C-h_a_|, que le pregunta por una cadena y le comenta todas las funciones que tienen esa cadena como parte de su nombre (la "a" sería para "apropos" [a propósito], o "about"[acerca]).

Otra fuente de información es el lector de documentación Info. Info es demasiado complejo para tratarlo aquí, pero si está interesado en explorarlo por si mismo, teclee |_C-h_i_| y lea el párrafo en la parte superior de la pantalla. Le dirá cómo conseguir más ayuda.

Los buffers de Emacs tienen modos asociados7. La razón para esto, es que sus necesidades cuando escribe un mensaje de correo son muy diferentes de sus necesidades cuando, por ejemplo, escribe un programa. Mejor que tratar de crear un editor que satisfaga cada necesidad particular en todo momento (que sería imposible), el diseñador de Emacs8 eligió hacer que Emacs se comporte de manera diferente dependiendo de qué hace Ud. en cada buffer individual. Así, los buffers tienen modos, cada uno diseñado para alguna actividad específica. Los aspectos principales que distinguen un modo de otros son las combinaciones de teclas, pero también pueden existir otras diferencias.

El modo más básico es el modo Fundamental, que realmente no tiene ningún comando especial.

De hecho, esto es todo lo que Emacs dice sobre el Modo Fundamental:

Obtuve así esa información: Teclee |_C-x_b_|, que es switch-to-buffer (cambiar al buffer), e introduje "foo" cuando se me preguntó por un nombre de buffer al que cambiar. Como no había anteriormente ningún buffer llamado "foo", Emacs creó uno y me cambio a él. Estaba en el modo fundamental por defecto, pero si no lo hubiese estado, podría haber tecleado "M-x fundamental-mode" para que estuviese. Todos los nombres de modo tienen un comando llamado <nombre-de-modo>-mode que pone el buffer actual en ese modo. Entonces, para averiguar más sobre este modo mayor, tecleé |_C-h_m_|, que consigue ayuda sobre el modo mayor actual del buffer en que está.

_____________________________________________

7 para colmo de males, hay "Modos Mayores" y "Modos Menores", pero en este momento no necesita conocer nada acerca de esto.

8 Richard Stallman, a veces también conocido como "rms", porque es su login.

Hay un modo ligeramente más útil llamado text-mode, (modo texto, que tiene los comandos especiales |_M-S_|, para centrar párrafo, y |_M-s_|, que invoca centrar línea. |_M-S_|, a propósito, significa exactamente lo que piensa: mantenga pulsadas la |_Meta__|y la tecla |_Shift_|, y presiona "S".

Pero no me tome la palabra en esto, cree un nuevo buffer, póngalo en modo texto, y teclee |_C-h_m_|. Puede que no entienda todo lo que Emacs le diga cuando lo haga, pero debería ser capaz de conseguir sacar alguna información útil de ello.

Esto es una introducción a algunos de los modos más comúnmente usados. Si los usa, asegúrese de que teclea en cada uno |_C-h_m_| alguna vez, para averiguar más sobre cada modo.

Si usa Emacs para programar en el lenguaje C, puede conseguir que él le haga toda la indentación automáticamente. Los archivos cuyos nombres terminan en .c o .h se abrirán automáticamente en el modo C. Esto significa que ciertos comandos especiales de edición, útiles para escribir programas en C, están disponibles. En el modo C, |_Tab_| está ligado a c-indent-command (indentar comandos C). Esto significa que presionando la tecla |_Tab_| no inserta realmente un carácter de Tabulación. En cambio, si presiona |_Tab_| en cualquier parte de una línea, Emacs automáticamente indenta esta línea correctamente para su ubicación en el programa. Esto implica que Emacs sabe algo sobre la sintaxis de C, (aunque nada sobre semántica (¡no puede asegurar que su programa no tenga errores!).

Para hacer esto, asuma que las líneas anteriores están indentadas correctamente. Esto significa que si en la línea anterior falta un paréntesis, un punto y coma, llaves, o cualquier otra cosa, Emacs indentará la línea actual de una manera peculiar inesperada. Cuando vea que hace esto, sabrá que debe buscar un error de puntuación en la línea anterior.

Puede usar esta característica para verificar que ha puntuado correctamente sus programas,

en vez de leer el programa entero_buscado_problemas, simplemente comience a indentar las líneas desde arriba hasta abajo con |_Tab_|, y cuando alguna se indenta de forma rara, verifique las líneas inmediatamente anteriores. En otras palabras, ¡deje a Emacs hacer el trabajo por Ud!.

Este es un modo mayor que no le servirá de nada a menos que tenga un compilador o un interprete para el lenguaje de programación Scheme en su sistema. Tener uno no es tan normal como, digamos, un compilador de C, pero se está haciendo cada vez más común, así que lo trataremos también.

Mucho de lo que es cierto para el modo Scheme es también cierto para el modo Lisp, si prefiere escribir en Lisp.

Bien, para complicar las cosas, Emacs viene con dos modos Scheme diferentes, porque la gente no podía decidir cómo querían que funcionara. El que estoy describiendo se llama cmuscheme, y luego, en la sección personalizando a Emacs, hablaré de cómo puede haber dos modos Scheme diferentes y qué hacer acerca de ello. Por ahora, no se preocupe si las cosas en su Emacs no coinciden con las que yo digo aquí. Un editor personalizable significa un editor impredecible, ¡y no hay vuelta de hoja!.

Puede ejecutar un proceso Scheme interactivo en Emacs con el comando M-x run-scheme. Esto crea un buffer llamado "*scheme*", que tiene el prompt habitual de Scheme. Puede teclear expresiones de Scheme en el prompt, presionar |_Intro_|, y Scheme las evaluará y mostrará la respuesta. Así, a fin de interactuar con el proceso de Scheme, podrá simplemente escribir todas sus aplicaciones y definiciones de función en el prompt. Es posible que haya escrito previamente código fuente Scheme en un algún archivo, y sería más fácil hacer su trabajo en el archivo y enviar las definiciones al buffer de proceso Scheme según sea necesario.

Si el archivo fuente termina en .ss o .scm, automáticamente se abrirá en el modo Scheme cuando lo encuentre con |_C-x_C-f_|. Si por alguna razón, no surge en el modo Scheme, puede hacerlo a mano con M-x scheme-mode. Este modo scheme no es lo mismo que el buffer que ejecuta el proceso Scheme; más bien, el que el buffer de código fuente esté en modo scheme significa que tiene comandos especiales para comunicar con el buffer de proceso.

Si está dentro de la definición de una función en el buffer de código fuente Scheme y teclea |_C-c_C-e_|, entonces esa definición será "enviada" al buffer de proceso, exactamente como si lo hubiera tecleado Ud. mismo. |_C-c_M-e_| envía la definición y entonces le lleva al buffer de proceso para hacer algo de trabajo interactivo. |_C-c_C-l_| carga un archivo de código Scheme (éste funciona desde el buffer de proceso o el buffer de código fuente). Y como otros modos de lenguajes de programación, al presionar |_Tab_| en cualquier lugar de una línea de código se indentará correctamente esa línea.

Si está en el prompt del buffer de proceso, puede usar ||_M-p_|| y |_M-n_| para moverse entre sus comandos anteriores (también conocido como la historia de entrada). Así que si está depurando la función 'rotar', y ya lo ha aplicado a los argumentos en el buffer de proceso, como:

entonces puede recuperar ese comando anterior tecleando ||_M-p_||en el prompt. Aquí no debería ser necesario volver a escribir expresiones largas en el prompt de Scheme, habitúese a usar la historia de entrada y ahorrará mucho tiempo.

Emacs conoce bastantes lenguajes de programación: C, C++, Lisp, y Scheme son simplemente algunos. Generalmente, sabe cómo indentarlos de forma intuitiva.

También puede editar y enviar correo en Emacs. Para entrar en un buffer de correo, teclee |_C-x_m_|. Necesita llenar los campos To: (A:) y Subjet: (Asunto:), y entonces use |_C-n_ | para ir, por debajo de la línea de separación, al cuerpo del mensaje (que está vacío cuando comienza por primera vez). No cambie o borre la línea de separación, o sino Emacs no será capaz de enviar su correo, use esa línea para distinguir el encabezamiento del correo, que le dice dónde enviar el correo, de los contenidos del mensaje.

Puede escribir lo que quiera por debajo de la línea de separación. Cuando esté listo para enviar el mensaje, simplemente teclee |_C-c_C-c_|, y Emacs lo enviará y hará que el buffer de correo desaparezca.

Los usuarios experimentados de Emacs son fanáticos de la eficiencia. <De hecho, frecuentemente acaban derrochando mucho tiempo buscando formas para ser más eficientes!. No quiero que le suceda esto, aunque hay algunas cosas fáciles con las que puede llegar a ser un mejor usuario de Emacs. A veces los usuarios experimentados hacen que los novatos se sientan tontos por no saber todos estos trucos, por alguna razón, la gente llega a hacerse religiosas sobre el uso "correcto" de Emacs. Allá vamos:

Cuando se mueve de un lado a otro, usa los medios más rápidos disponibles. Ud. sabe que |_C-f_| es forward-char (un carácter hacia adelante) ¿suponía que |_M-f_| es forward-word (una palabra hacia delante)? |_C-b_| es backward-char (un carácter hacia atrás). ¿Supone qué hace |_M-b_|? Sin embargo, esto no es todo, puede avanzar una frase cada vez con |_M-e_ |, siempre que escriba sus frases de modo que haya siempre dos espacios después del punto final, (de otra manera Emacs no puede distinguir donde termina una frase y comienza la siguiente). |_M-a_| es backward-sentence (una frase atrás).

Si ve que usa repetidamente |_C-f_| para llegar al final de la línea, avergüéncese, y asegúrese de usar |_C-e_| en su lugar, y |_C-a_| para ir al principio de la línea. Si usa muchos |_C-n_| para bajar pantallas de texto, avergüéncese mucho, y usa |_C-v_| siempre. Si usa repetidamente ||_C-p_|| para avanzar pantallas, no se atreva a enseñar la cara, y use |_M-v_| en su lugar.

Si se está acercando al final de una línea y se da cuenta de que hay una palabra mal tecleada o de que se ha olvidado alguna en algún lugar anterior de la línea, no use la |_Retroceso_| o ||_Supr_|| para volver a ese punto. Eso requeriría volver a escribir porciones enteras de texto perfecto. En vez de eso, use combinaciones de |_M-b_|, |_C-b_|, y |_C-f_| para moverse a la ubicación precisa del error, arréglelo, y entonces use |_C-e_| para moverse al fin de la línea nuevamente.

Cuando tiene que escribir un nombre de archivo, nunca teclee el nombre completo. Solamente escriba lo suficiente para identificarlo singularmente, y deje que Emacs termine el trabajo presionando |_Tab_| o ||_Espacio_||. ¿Por qué teclear de más cuando puede derrochar ciclos de CPU en su lugar?

Si escribe algún tipo de texto simple, y de algún modo su auto-llenando (auto-filling)lo ha fastidiado, use |_|M-q_||, que es rellenado de párrafo en los modos de texto comunes. Esto "ajustará" el párrafo en el que está, como si hubiese sido llenado línea a línea, pero sin tener que liarse haciéndolo a mano. ||_M-q_|| trabajará desde dentro del párrafo, o desde su comienzo o final.

A veces es útil usar |_C-x_u_|, (undo [deshacer]), que tratará de "deshacer" el (los) último(s) cambio(s) que hizo. Emacs decidirá cuanto deshacer; habitualmente decide muy inteligentemente.

Llamándolo repetidamente deshará más y más, hasta que Emacs no pueda recordar qué cambios se hicieron.

Emacs es tan grande, y tan complejo, que de hecho tiene ¡su propio lenguaje de programación!. No bromeo: para personalizar Emacs ajustándolo a sus necesidades, tiene que escribir programas en este lenguaje. Se llama Emacs Lisp, y es un dialecto de Lisp, así que si tiene experiencia previa en Lisp, le parecerá bastante amistoso. Si no, no se preocupe: no voy a profundizar mucho, porque definitivamente se aprende mejor practicando. Para aprender realmente a programar Emacs, deberá consultar las páginas de información de Emacs Lisp, y leer mucho código fuente de Emacs Lisp.

La mayor parte de la funcionalidad de Emacs está definida en archivos de código de Emacs Lisp9. La mayoría de estos archivos se distribuyen con Emacs y colectivamente son conocidos como la "Biblioteca de Emacs Lisp". La ubicación de esta biblioteca depende de cómo se instaló Emacs en su sistema, son ubicaciones comunes /usr/lib/emacs/lisp, /usr/lib/emacs/19.19/lisp/, etc.

El 19.19 es el número de versión de Emacs, y podría ser diferente en su sistema.

No necesita hurgar por su sistema de archivos buscando la biblioteca de lisp, porque Emacs tiene la información almacenada internamente, en una variable llamada load-path (trayectoria de carga). Para averiguar el valor de esta variable, es necesario evaluarla; esto es, hacer que el intérprete de lisp de Emacs consiga su valor. Hay un modo especial para evaluar las expresiones de Lisp en Emacs, llamado modo lisp interactivo (lisp-interaction-mode). Comúnmente, hay un buffer llamado "*scratch*" que está ya en este modo. Si no lo puede encontrar, cree un nuevo buffer con cualquier nombre, y escriba M-x lisp-interaction-mode dentro de él.

Ahora tiene un espacio de trabajo para interactuar con el intérprete Lisp de Emacs. Teclee esto:

y entonces presione ||_C-j_|| al finalizar. En el modo Lisp interactivo, ||_C-j_|| está ligado a eval-print-last-sexp (evaluar-imprimir-última-sexp). Una "sexp" es una "s-expresion", lo que significa un grupo balanceado de paréntesis, incluido el caso de que no haya ninguno. Bueno, esto es simplificarlo un poco, pero irá entendiendo que son según programe con Emacs Lisp. De cualquier manera, al evaluar load-path debería conseguir algo como esto:

Por supuesto, no tendrá el mismo aspecto en cada sistema, puesto que es dependiente de cómo se instaló Emacs. El ejemplo de arriba viene de mi PC 386 que funciona con Linux. Como indica lo anterior, load-path es una lista de cadenas. Cada cadena nombra un directorio que podría contener archivos de Emacs Lisp. Cuando Emacs necesita cargar un archivo de código Lisp, va buscándolo en cada uno de estos directorios, en orden. Si un directorio se nombra pero no existe en el sistema de archivos, Emacs simplemente lo ignora.

_____________________________________________

9 A veces llamados no oficialmente "Elisp".

Cuando Emacs arranca, automáticamente trata de cargar el archivo .emacs desde su directorio de usuario. Por lo tanto, si quiere hacer personalizaciones en Emacs, deberá ponerlas en .emacs. La personalización más común son las teclas ligadas, así que aquí está cómo hacerlo:

global-set-key (fijar teclas globalmente) es una función de dos argumentos: la tecla a la que ha de ser ligada, y la función a la que ligarla. La palabra "global" significa que esta tecla ligada tendrá efecto en todos los modos mayores (hay otra función, local-set-key, (fijar teclas localmente), que liga una tecla en un único buffer). Arriba, he ligado |_C-c_l_| a la función goto-line (ir a tal línea).

La tecla se describe usando una cadena. La sintaxis especial ""C-<carácter>" significa mantener pulsada la tecla |_Control_| mientras se presiona <carácter>. Así mismo, ""M-<carácter>" indica la tecla |_Meta_|.

Todo eso está muy bien, ¿pero cómo supe que el nombre de la función era "goto-line"?. Puedo saber que quiero ligar |_C-c_l_| a alguna función que pregunta por un número de línea y mueve el cursor a esa línea, pero ¿cómo hice para averiguar el nombre de esa función?

Aquí es donde intervienen las facilidades de ayuda de Emacs. Una vez que ha decidido qué tipo de función busca, puede usar Emacs para rastrear su nombre exacto. He aquí una manera rápida y sucia para hacerlo: puesto que Emacs completa los nombres de función, simplemente escriba |_C-h_f_| (que es describe-function (describir función), recuérdelo), y entonces presione |_Tab_| sin escribir nada más. Esto pide a Emacs que complete la cadena vacía _en otras palabras, ¡la terminación automática se corresponderá con cada una de las funciones!. Puede tardar un momento en construir la lista de funciones, ya que Emacs tiene muchas funciones internas, pero mostrará todo lo que entre en la pantalla cuando esté listo.

En este momento presione ||_C-g_|| para abandonar la función describir función. Habrá un buffer llamado "*Completions*", que contiene la lista de terminaciones automáticas que acaba de generar.

Cambie a este buffer. Ahora puede usar |_C-s_|, isearch, para buscar las funciones probables. Por ejemplo, es una suposición segura que una función que pregunta por un número de línea y entonces va a esa línea contendrá la cadena "line (línea)" en su nombre. Por lo tanto, simplemente comience buscando la cadena "line" , y acabará encontrando lo que busca.

Si quiere otro método, puede usar |_C-h_a_|, command-apropos, para mostrar todas las funciones cuyos nombres se ajustan a la cadena dada. La salida de command-apropos es un poco más difícil de clasificar, que simplemente buscar una lista de terminación automática, en mi opinión, pero puede encontrar que tiene distintas sensaciones. Pruebe ambos métodos y a ver que opina.

Siempre existe la posibilidad de que Emacs no tenga ninguna función predefinida para hacer lo que está buscando. En esta situación, tiene que escribir la función Ud. mismo. No voy a hablar de cómo hacer eso, debería buscar en la biblioteca de Emacs Lisp ejemplos de definiciones de función, y leer las paginas Info sobre Emacs Lisp. Si resulta que conoce a un gurú local de Emacs, pregúntele cómo hacerlo. Definir sus propias funciones de Emacs no es un gran asunto, para darle una idea, yo he escrito 131 de ellas durante más o menos el último año. Requiere un poco de práctica, pero la curva de aprendizaje no es empinada.

Otra cosa que la gente hace a menudo en su .emacs es asignar a ciertas variables los valores preferidos. Por ejemplo, ponga esto en su .emacs y entonces inicie un nuevo Emacs:

Emacs verifica el valor de la variable inhibit-startup-message (bloquear mensaje de arranque) para decidir si muestra la información sobre la versión y la falta de garantía cuando arranca. La expresión de Lisp de arriba usa el comando setq para asignar a esa variable el valor `t', que es un valor especial de Lisp que significa true (verdadero). Lo contrario de `t' es `nil' (nada o nulo), que es el valor false (falso) designado en Emacs Lisp. He aquí dos cosas que están en mi |_.emacs_| que podría encontrar útiles:

La primera expresión hace que las búsquedas (incluyendo isearch) sean insensibles a mayúsculas y minúsculas; esto es, la búsqueda encontrará versiones de un mismo carácter sea mayúscula o minúscula aunque la cadena de búsqueda contenga únicamente la versión en minúscula. La segunda expresión establece que la indentación por defecto para las sentencias en lenguaje C sea un poco menor de lo normal, esto es solamente una preferencia personal; encuentro que esto hace el código C más legible.

El carácter de comentario en Lisp es ";". Emacs ignora cualquier cosa que siga a uno de éstos, a menos que aparezca dentro de una cadena literal, como esta:

Es una buena idea comentar sus cambios en los archivos Lisp, porque seis meses después no se acordará en qué estaba pensando cuando los modificó. Si el comentario aparece sólo en una línea, precédalo con dos punto y coma. Esto ayuda a Emacs a indentar los archivos Lisp correctamente.

Puede encontrar información sobre las variables internas de Emacs de las mismas formas que con las funciones. Use |_C-h_v_|, describe-variable para hacer una lista de terminación automática, o use |_C-h_C-a_|, apropos. Apropos difiere de |_C-h_a_|, command-apropos, en que muestra variables y funciones en vez de solamente funciones.

La extensión por defecto para los archivos de Emacs Lisp es .el, como en c-mode.el. Sin embargo, para hacer que el código Lisp se ejecute más rápido, Emacs permite que sea byte-compiled (compilado a un formato interno), y estos archivos de código Lisp compilado terminan en .elc en vez de .el. La excepción a esto es su archivo .emacs, que no necesita la extensión .el porque Emacs sabe buscarlo para arrancar.

Para cargar un archivo de código Lisp interactivamente, use el comando M-x load-file (cargar archivo). Le preguntará por el nombre del archivo. Para cargar archivos Lisp desde dentro de otros archivos Lisp, haga esto:

Emacs añadirá la extensión .elc al nombre del archivo e intentará encontrarlo en algún lugar del load-path. Si falla, lo intenta con la extensión .el; si falla esto, usa la cadena literal tal y como es pasada a load. Puede compilar (byte-compile) un archivo con el comando M-x byte-compile-file, pero si modifica el archivo a menudo, probablemente no merezca la pena. Sin embargo no debería compilar de esa manera su .emacs, ni siquiera darle la extensión .el.

Después de que .emacs se ha cargado, Emacs busca un archivo llamado default.el para cargarlo.

Comúnmente se ubica en un directorio en la trayectoria de carga (load-path) llamado site-lisp o local-elisp o algo parecido (ver el ejemplo load-path que di hace un rato). La gente que mantiene Emacs en un sistema multiusuario usa default.el para hacer cambios que afectarán los Emacs de todos, puesto que todos los Emacs lo cargan después de los .emacs personales. default.el no debería ser compilado, ya que tiende a ser modificado frecuentemente.

Si el .emacs de una persona contiene algún error, Emacs no intentará cargar default.el, sino que simplemente se detendrá, destellando un mensaje diciendo "Error in init file." (Error en el archivo de inicio) o algo similar. Si ve este mensaje, probablemente algo vaya mal con su .emacs.

Hay un tipo más de expresión que a menudo va en un .emacs. La libreria de Emacs Lisp a veces ofrece múltiples paquetes para hacer lo mismo de diferentes formas. Esto significa que tiene que especificar cuál quiere usar (o tendrá el paquete por defecto, que no es siempre el mejor para todos los propósitos). Un área donde esto sucede es en las características de interacción del Scheme de Emacs. Hay dos interfaces diferentes de Scheme distribuidos con Emacs (al menos en la versión 19): xscheme y cmuscheme.

Resulta que el interfaz ofrecido por cmuscheme me gusta mucho más que el que ofrece xscheme, pero el que Emacs usará por defecto es xscheme. ¿Cómo puedo hacer que Emacs actúe de acuerdo con mi preferencia?. Puse esto en mi .emacs:

La función autoload (auto carga) toma el nombre de una función (citada con "'", por razones que tienen que ver con cómo funciona Lisp) y le dice a Emacs que esta función está definida en un determinado archivo. El archivo es el segundo argumento, una cadena (sin la extensión .el o .elc) indicando el nombre del archivo a buscar en la trayectoria de carga load-path.

Los argumentos restantes son opcionales, pero necesarios en este caso: el tercer argumento es una cadena de documentación para la función, de modo que si llama a describe-function (describir-función), consigue alguna información útil. El cuarto argumento le dice a Emacs que esta función autocargable puede ser llamada interactivamente (esto es, usando |_M-x_|). Esto es muy importante en este caso, porque uno debería poder teclear M-x run-scheme para comenzar un proceso de scheme que se ejecuta bajo Emacs.

Ahora que run-scheme ha sido definido como una función autocargable, ¿qué sucede cuando tecleo M-x run-scheme?. Emacs mira la función run-scheme, ve que está establecida para ser autocargable, y carga el archivo nombrado por la autocarga (en este caso, cmuscheme). El archivo compilado cmuscheme.elc existe, así que Emacs lo cargará. Ese archivo debe definir la función run-scheme, o habrá un error de autocarga. Por suerte, define run-scheme, así que todo va sin tropiezos, y consigo mi interfaz preferida de Scheme10.

Una autocarga es como una promesa a Emacs, de que cuando llegue el momento, puede encontrar la función especificada en el archivo en el que le dice que mire. A cambio, consigue algún control sobre lo que se carga. También, la autocarga ayuda a reducir el tamaño de Emacs en la memoria, al no cargar ciertas características hasta que se pidan. Muchos comandos no están definidos realmente como funciones cuando Emacs se inicia. Más bien, están simplemente preparados para autocargarse desde cierto archivo. Si nunca invoca el comando, nunca se carga. Este ahorro de espacio es vital para el funcionamiento de Emacs: si cargara todos los archivos disponibles en la biblioteca Lisp, Emacs tomaría veinte minutos simplemente para arrancar, y una vez hecho, podría ocupar la mayor parte de la memoria disponible en su máquina. No se preocupe, no tiene que establecer todas estas autocargas en su .emacs; ya se tomaron en cuenta cuando Emacs se desarrolló.

No le he contado todo lo que se puede saber sobre Emacs. De hecho, no creo haberle contado siquiera un 1% de lo que se puede saber sobre Emacs. Aunque sabe suficiente para proseguir, todavía hay montones de comodidades y trucos que ahorran tiempo que debería averiguar. La mejor forma de hacerlo es esperar hasta que vea que necesita algo, y buscar entonces una función que lo haga.

La importancia de estar cómodo con las facilidades de ayuda en línea de Emacs no puede enfatizarse lo suficiente. Por ejemplo, suponga que quiere poder insertar los contenidos de algún archivo en un buffer que ya está trabajando sobre un archivo diferente, para que el buffer contenga a ambos. Si intuyese que hay un comando llamado insert-file (insertar archivo), tendría razón. Para verificar su acertada suposición, teclee C-h f. En el prompt del minibuffer, introduzca el nombre de una función sobre la que quiera ayuda. Puesto que sabe que hay terminación automática en los nombres de funciones,_y_puede suponer que el comando que busca comienza con "insert", escriba insert y presiona |_Tab_|. Esto le muestra todos los nombres de función que comienzan con "insert", e "insert-file' es uno de ellos.

De este modo completa el nombre de función y lee sobre como trabaja, y entonces usa M-x insert-file._Si se está preguntando si también está ligado a una tecla, escribe C-h w insert-file |_Intro_|, y averígüelo. Cuanto más sepa de las facilidades de ayuda de Emacs, más fácilmente podrá hacer preguntas a Emacs acerca de sí mismo. La capacidad de hacerlo, combinada con un espíritu de exploración y un deseo de aprender nuevas formas de hacer las cosas, puede acabar por ahorrarle mucho tecleado.

_____________________________________________

10 A propósito, cmuscheme era la interfaz de la que hablaba antes, en la sección sobre el trabajo con Scheme, así que si quiere usar algo de este manual, necesita asegurarse de que ejecuta cmuscheme.

Para pedir una copia del manual de usuario de Emacs (Emacs user's manual) y/o el manual de Programación en Emacs Lisp (Emacs Lisp Programming manual), debe escribir a:

Ambos manuales se distribuyen electrónicamente con Emacs, en una forma legible usando el lector de documentación Info (C-h i), pero puede encontrar más fácil tratar con freeware que con las versiones en línea. Además, sus precios son bastantes razonables, y el dinero va a una buena causa, ¡software gratuito de calidad!. En algún momento, debería teclear C-h C-c para leer las condiciones de copyright de Emacs. Es más interesante de lo que puede pensar, y le ayudará a aclarar el concepto de software libre. Si cree que el termino "free software" simplemente significa que el programa no cuesta nada, por favor ¡lea el copyright en cuanto tenga tiempo!.