editores.tex

%Autor: miguev, mojopikon, faraox
%miguev: 2 + 5
%mojopikon: 3
%faraox: 3


\chapter{Editores de texto}
\label{editores.tex}

\index{Texto!Editores}

\section{VI \& VIM}

\index{VI}
\index{VIM}


{\sf VI} es un editor de texto visual, de pantalla completa, basado en
el editor de  línea {\tt ex}. Es  un editor poco intuitivo  y con mala
prensa entre los estudiantes que dan sus primeros pasos en Linux/UNIX,
pero por otra parte es el  editor favorito de los usuarios avanzados y
de muchos programadores. Es además un editor que se puede encontrar en
cualquier sistema UNIX, desde antiguas  estaciones Sun Solaris o HP-UX
hasta  las  más  recientes  distribuciones  de  GNU/Linux  o  FreeBSD,
OpenBSD, etc.

{\sf  VI}  es  además  un   editor  muy  potente,  que  permite  hacer
complicadas operaciones  en grandes ficheros con  unos pocos comandos,
por lo que su aprendizaje  puede ahorrarnos mucho tiempo. Otra ventaja
de {\sf VI}  es que al ser tan corriente  suele encontrarse incluso en
disquetes de rescate. Lógicamente poco se puede rescatar si no se sabe
manejar el único editor disponible en un momento de emergencia.

Pero el manejo de {\sf VI}  es realmente incómodo si nos enfrentamos a
la  versión clásica.  Por ejemplo  no podemos  usar los  cursores para
movernos por el  texto, debemos pasar al llamado modo  {\em comando} y
utilizar letras para movernos.

En este  curso utilizaremos el  editor {\sf VIM}. {\sf  VIM} significa
``{\bf V}i {\bf IM}proved'' (en español ``{\bf VI M}ejorado''), y como
su nombre  indica es un  clon (muy)  mejorado del clásico  editor {\sf
VI}. {\sf VIM}  es bastante más amigable que {\sf  VI}, ya que permite
un uso más intuitivo (p.ej. los cursores y otras teclas para moverse).
Además,  si  se compila  adecuadamente  (y  suele ser  así)  incorpora
coloreado de sintaxis para casi  todos los lenguajes de programación y
ficheros  de configuración  que puedas  encontrar en  Linux/UNIX. Otra
característica  muy interesante  de  {\sf VIM}  es  la posibilidad  de
utilizar un  interfaz gráfico, lo que  aumenta el confort y  mejora el
rendimiento del programador.

Lo primero que hay que aprender con {\sf VI} es la filosofía de los dos
modos de  trabajo: \index{VIM!modos} el  modo {\em comando} y  el modo
{\em edición}. El  modo comando se utiliza solamente  para dar órdenes
al editor,  decirle que haga  cosas como  borrar una línea,  buscar un
patrón, ir a una determinada línea, guardar el fichero, salir, etc. El
modo  {\em edición}  se utiliza  solamente para  escribir texto  en el
fichero.  Es  muy  importante  familiarizarse con  esta  filosofía  de
funcionamiento, ya que resulta imprescindible para cualquier operación
que se quiera realizar con {\sf VIM}.

En adelante  nos referiremos  al editor como  {\sf VI}  cuando digamos
algo que sea común a todas las versiones de {\sf VI}, y como {\sf VIM}
cuando se trate de extensiones propias de {\sf VIM}.

Para ejecutar este editor el comando  es {\tt vi}. Si tienes instalada
otra  versión de  {\sf  VI} pero  quieres utilizar  {\sf  VIM} no  hay
problema,  simplemente  ejecuta  {\tt  vim}. Si  quieres  utilizar  la
interfaz gráfica de {\sf VIM} ejecuta {\tt gvim}.\index{GVIM}

Aunque  conserva el  nombre de  {\sf VI}  estamos trabajando  con {\sf
VIM}. Este comando admite varias opciones  que se le pueden pasar como
parámetros, p.ej. el nombre del fichero que queremos editar:

\begin{verbatim}
$ vi fichero
\end{verbatim}

También puedes especificar  la línea en la que quieres  empezar con el
parámetro {\tt +n}. Por ejemplo para empezar en la línea 12:

\begin{verbatim}
$ vi fichero +12
\end{verbatim}

{\tt  VIM} comienza  siempre  en modo  {\tt  comando}, preparado  para
realizar operaciones  sobre el  fichero. Una  de estas  operaciones es
pasar al modo {\tt edición}. Esta transición puede hacerse de 8 formas 
diferentes.

\begin{table}[htbp]
\centering
\index{VIM!insertar}
\begin{tabular}{|c|p{0.88\textwidth}|}
\hline
{\tt i} & Comienza a insertar texto en la posición del cursor. \\
{\tt a} & Comienza a insertar texto en la posición siguiente a la del cursor. \\
{\tt o} & Comienza a insertar texto en una nueva línea debajo del cursor. \\
{\tt s} & Borra el carácter en la  posición del cursor y comienza a insertar texto. \\ 
\hline
{\tt I} & Comienza a insertar texto al principio de la línea. \\
{\tt A} & Comienza a insertar texto al final de la línea. \\
{\tt O} & Comienza a insertar texto en una nueva línea encima del cursor. \\
{\tt S} & Borra la línea en la  posición del cursor y comienza a insertar texto. \\

\hline
\end{tabular}
\caption{Pasar el modo {\em edición} en {\sf VI}}
\end{table}

Para pasar  del modo  {\em edición}  al modo  {\em comando}  basta con
pulsar {\tt  ESC}. A  continuación vamos a  editar un  pequeño fichero
para familiarizarnos con sus comandos básicos. Comenzamos invocando al
editor desde la  línea de comandos (suponemos que  estás utilizando la
interfaz gráfica, aunque también puedes prescindir de ella):

\begin{verbatim}
$ gvim hola.c
\end{verbatim}

\begin{figura}{gvim1}{0.85}
\caption{Interfaz gráfica de VIM con un fichero nuevo (vacío)}
\end{figura}

La última línea  de la interfaz (o de la  consola) debería parecerse a
esto:

\begin{verbatim}
"hola.c" [New File]                                  0,0-1         All
\end{verbatim}

Esta  línea es  la {\em  barra de  estado} del  editor. Es  aquí donde
teclearemos los comandos y donde  aparecerá cierta información como el
modo en el que estamos (comando, edición, reemplazo, etc.), la línea y
columna  en la  que estamos,  el porcentaje  del documento  en el  que
estamos, si el fichero ha sido salvado y su tamaño.

A  continuación pulsamos  la tecla  {\tt i}  para pasar  al modo  {\em
edición}. Observamos que la barra de estado se muestra diferente:

\begin{verbatim}
-- INSERT --                                         0,1           All
\end{verbatim}

Ahora es el momento de teclear, escribe el siguiente código:

\begin{verbatim}
#include <stdio.h>

int main()
{
    printf("Hola Mundo\n");
}
\end{verbatim}

\begin{figura}{gvim2}{0.85}
\caption{Interfaz gráfica de VIM con código C coloreado}
\end{figura}

Cuando tengas  esto escrito, pulsa {\tt  ESC} para pasar al  modo {\em
comando}.  Entonces teclea  la orden  {\tt  :w} y  pulsa {\tt  Enter}.
Veremos como la orden {\tt :w}  aparece en la barra de estado mientras
la tecleamos,  y luego al  ejecutarla se muestra información  sobre el
resultado, en este  caso información sobre el fichero  que acabamos de
guardar.\index{VIM!guardar}

\begin{verbatim}
"hola.c" [New] 6L, 62C written                       6,1           All
\end{verbatim}

En esta  línea {\sf VI} nos  indica que ha escrito  el fichero hola.c,
que es nuevo, que tiene un tamaño de 62 caracteres en 6 líneas. Además
al terminar de escribirlo  estamos en la línea 6 y en  la columna 1, y
podemos ver todo el fichero.

Si tu  versión de {\sf VIM}  tiene soporte para coloreado  de sintaxis
\index{VIM!coloreado de sintaxis}
probalmente ya  estará funcionando  y verás las  palabras {\tt  int} e
{\tt include}  de distinto color.  Sin aún  no estás viendo  el código
coloreado prueba a pasar al modo  {\em comando} (pulsando {\tt ESC}) y
ejecutar el comando  {\tt :syntax on} (para los  comandos que empiezan
en {\tt  :} hay que  pulsar {\tt Enter} al  final). Si te  devuelve el
mensaje  de que  esa función  no está  implementada es  que no  tienes
disponible el coloreado de sintaxis. Si por el contrario funciona pero
no te gusta y quieres quitarlo  ejecuta el comando {\tt :syntax off} y
desaparecerán los colores. En la interfaz  gráfica de {\sf VIM} hay un
menú {\sf Esquemas  de colores} dentro del menú  {\sf Editar}. También
puedes cambiar el esquema de colores  desde la interfaz de consola del
{\sf VIM} con el comando {\tt :colors esquema}. Por ejemplo, activa el
coloreado de sintaxis y ejecuta {\tt :colors koehler}.

% Ahora pensemos  que queremos  eliminar esas líneas  de tres  guiones y
% cambiarlas  por  líneas  de  cinco asteriscos.  Pasamos  a  modo  {\tt
% comando}, situamos el cursor en una de esas línas y pulsamos {\tt dd}.
% Veremos como  la línea entera  desaparece. Repetimos lo mismo  con las
% otras líneas. Ahora nos situamos en  la primera línea y pasamos a modo
% {\tt  edición},  escribimos  cinco  asteriscos y  pulsamos  {\tt  \flq
% Enter\frq }. Volvemos al modo {\tt comando}, colocamos el cursor en la
% nueva línea de asteriscos y pulsamos  de nuevo {\tt dd}, vemos cómo la
% línea desaparece.  Situamos el cursor  en el  principio de la  línea y
% pulsamos {\tt P}, vemos cómo la  línea que habíamos borrado se inserta
% {\em  antes} del  cursor. Si  situamos el  cursor al  principio de  la
% tercera línea y  pulsamos {\tt p} vemos cómo la  línea se inserta {\em
% después} del cursor. Añadimos las restantes líneas de asteriscos donde
% estaban las de guiones.

En adelante, el comando {\tt x} significará pulsar la tecla {\tt x} en
modo {\em comando}, el comando  {\tt :letras} significará teclear {\tt
:letras} en modo  comando y pulsar {\tt Enter}.  Cualquier comando del
primer tipo puede  modificarse teclando un número, lo que  hará que se
ejecute ese número de veces (el comando {\tt 4x} es equivalente a {\tt
xxxx}). Si te equivocas  tecleando cualquier comando puedes cancelarlo
pulsando {\tt Esc}.

Para  deshacer cualquier  operación  realizada pulsamos  en modo  {\em
comando} la tecla {\tt u}. Para  salir del editor {\bf sin} guardar el
fichero utiliza  el comando  {\tt :q!}. Probablemente  realizarás esta
operación con mucha  frecuencia al principio, cuando  se cometas algún
error grave como teclear una palabra  sin pasar al modo {\em edición}.
En el modo  {\em comando} cada tecla tiene su  función, y es diferente
además si está en mayúsculas que  si está en minúsculas. Por lo tanto,
una regla de oro con {\sf VI} es: {\bf cuando no sepas con qué comando
hacer algo, no pruebes teclas al azar}. Tampoco es nada bueno utilizar
la tecla. Y por supuesto, cuando estés editando algo importante guarda
el fichero con  frecuencia con el comando {\tt :w},  sobre todo en las
primeras semanas de  uso. Para salir de {\sf VI}  guardando el fichero
utiliza el comando {\tt :x}.

Una utilidad  que te puede  resultar interesante es  ejecutar comandos
del sistema desde la misma consola en la que estamos trabajando con el
{\sf  VIM}. En  modo  {\em comando}  escribimos  {\tt :!comando},  por
ejemplo, si escribimos {\tt :!ls}  nos mostrará un listado de archivos
del directorio  en el  que nos encontramos.  Esto te  permite compilar
programas o  documentos mientras editas  uno o más ficheros  de código
fuente,  incluso  puedes ejecutar  una  consola  de sistema  desde  el
editor, con el comando {\tt :sh}

Para buscar palabras dentro de un  documento es fácil, solo tienes que
\index{VIM!búsqueda} escribir  en modo {\em comando}  {\tt /palabra} y
si salen  varios resultados, pulsando  {\tt n} pasarás al  siguiente y
pulsando {\tt N}  al anterior. Si prefieres que la  búsqueda sea hacia
atrás (desde el  final hacia el principio del fichero)  el comando que
necesitas es  {\tt ?palabra}.  También con esta  búsqueda pasas  de un
resultado a otro pulsando {\tt n}.

Si lo que  necesitas es desplazarte por un documento  muy grande (como
por ejemplo el  código fuente de un programa) a  líneas concretas {\sf
VIM} lo  soluciona. Para desplazarnos a  la línea 60 de  un documento,
escribe en modo {\em comando} {\tt 60}  y luego pulsa {\tt S-g} o {\tt
G}. Si  pulsas sólo  {\tt S-g}  o {\tt  G} te  desplazas al  final del
fichero, y si  pulsas {\tt gg} (pulsas {\tt g}  dos veces seguidas) te
desplazas al principio del fichero.

Para desplazamientos  más cortos dispones  del comando {\tt  0} (cero)
que te  sitúa el principio  de la línea, \verb.^.  que te sitúa  en el
primer caracter no blanco (espacio  o tabulador) de la línea, \verb.$.
que te sitúa al final de la línea, {\tt w} te sitúa al principio de la
siguiente palabra, y {\tt b} hace lo mismo con la anterior palabra. El
comando  \verb.).  te desplaza  a  la  siguiente frase,  mientras  que
\verb.(. te  desplaza a  la anterior. Del  mismo modo  puedes utilizar
\verb.{. y \verb.}. para saltar de párrafo en párrafo.

Si en  lugar de desplazarte  por el fichero  lo que quieres  es borrar
parte de su contenido estos mismos comandos, pulsando previamente {\tt
d}, hacen lo siguiente: {\tt d0}  borra desde el principio de la línea
hasta  justo antes  del cursor,  {\tt D}  o \verb.d$.  borra desde  el
cursor hasta  el final  de la  línea, {\tt dw}  borra desde  el cursor
hasta el principio de la siguiente palabra, {\tt db} borra desde justo
antes  del cursor  hasta  el principio  de  la palabra  en  la que  se
encuentre el cursor, {\tt dd} borra la línea en la que se encuentre el
cursor, {\tt dj} borra la línea en  la que se encuentre el cursor y la
que  estén justo  debajo,  {\tt 34dj}  borra  la línea  en  la que  se
encuentre el cursor y las siguientes 34 líneas que estén justo debajo,
\verb.d). borra  desde el  cursor hasta el  principio de  la siguiente
frase, \verb.d(. borra desde el cursor  hasta el principio de la frase
en la  que se  encuentre el  cursor, \verb.d}.  borra desde  el cursor
hasta el final del párrafo en la que se encuentre el cursor, \verb.d{.
borra desde el cursor hasta el final del párrafo anterior.

A lo mejor  te interesa pegar en  otro sitio ese trozo  de fichero que
has borrado,  o prefieres copiar y  pegar en lugar de  cortar y pegar.
Claro que puedes  hacerlo con {\sf VI} y  seleccionando exactamente lo
que  quieras. Para  seleccionar una  parte del  fichero sitúate  en un
extremo  de  la  selección  (principio  o  final),  pulsa  {\tt  v}  y
desplázate hasta  el otro  extremo de la  selección. Para  cancelar la
selección pulsa  {\tt Esc}. Una  vez que tienes el  texto seleccionado
puedes cortarlo pulsando {\tt d} o copiarlo pulsando {\tt y}.

Para pegar lo que has copiado o  cortado has de situar el cursor en la
posición  deseada  y contemplar  dos  opciones  para pegar  el  texto:
pulsando {\tt p} el texto se insertará {\em justo después} del cursor,
pulsando {\tt S-p}  o {\tt P} el texto se  insertará {\em justo antes}
del cursor.

Cuando cortas o copias una región de  texto ésta se guarda en una zona
de memoria, lo que se denomina  un {\em buffer}. Mientras no salgas de
{\sf VIM}  este buffer se  conserva completamente hasta que  vuelvas a
cortar  o copiar  otra  región.  Ten cuidado  porque  borrar algo  con
cualquier comando también se considera cortar, por lo que sobreescribe
el buffer. Este  buffer se conserva además entre ficheros,  por lo que
puedes cortar o copiar  en un fichero y pegar en  otro, siempre que no
salgas del  editor para hacer  esta maniobra.  Si sales del  editor se
conserva sólo una parte del buffer, suele ser suficiente para regiones
no muy grandes, pero no  te confíes\footnote{En el momento de escribir
esto la versión de VIM 6.1-474 limita el buffer a 50 líneas}.

Si quieres  cortar o  copiar de un  fichero y pegar  en otro  lo mejor
es  que  abras ambos  ficheros  con  el  mismo {\sf  VI},  simplemente
ejecutando:

\begin{verbatim}
$ vi fichero1 fichero2
\end{verbatim}

Con esto tienes varios ficheros abiertos,  con un buffer para cada uno
\index{VIM!buffers} (aquí entendemos  buffer en el sentido  con el que
lo hacemos  al hablar  de Emacs  en la  sección \ref{emacs})  y puedes
pasar de un buffer a otro con el comando {\tt :bN} donde {\tt N} es el
número del  buffer (se numeran  empezando por  $1$). Para pasar  de un
buffer a otro primero  debes guardar a fichero el buffer  en el que te
encuentres (con el comando {\tt :w}).

Otro comando que te ayudará si  tienes que programar es el comando \%.
Si estás trabajando  con algunos lenguajes cuyas  sintaxis manejan con
mucha frecuencia \verb.(., \verb.{. o  \verb.{. , {\sf VIM} te permite
con pulsar la  tecla \% situarte sobre uno de  estos caracteres que te
muestre  el  de cierre  o  apertura  que  le corresponda.  

\section{GNU Emacs}
\label{emacs}
\index{Emacs}

{\sf Emacs}, junto con {\sf VI},  ha sido uno de los primeros editores
de  texto para  UNIX.  A  pesar de  visualmente  presenta un  interfaz
similar al  de un  editor de  texto corriernte,  como podría  ser {\sf
joe},  el {\sf  edit} de  MS-DOS, o  similar, lo  cierto es  que tiene
muchísimas posibilidades que no atribuirías  a un editor de texto para
consola. Por ejemplo, el indentado  automático de código Pascal, Java,
C,  o cualquier  lenguaje  para el  que haya  escrito  un módulo  para
Emacs de  asistencia a  la programación,  nos ofrece  posibilidades de
trabajar con  CVS, enviar correo  electrónico, y un largo  etcétera de
posibilidades. Como anécdota cabe contar,  para que te hagas una idea,
el manual de GNU Emacs, en formato ASCII ocupa cerca de 1.1 MB.

Hablemos de cómo manejarse con los  menús de Emacs. Existen cientos de
combinaciones de teclas en Emacs que nos permiten hacer cualquier cosa
sin  ver  un  menú.  Los  usuarios  expertos  de  Emacs  valoran  esta
posibilidad, pues a la hora de  escribir con prisas, un menú puede ser
algo muy incómodo.  Pero para nosotros que  estamos empezando, debemos
recordar:
la tecla {\tt F10} es nuestra amiga.

Esta tecla  nos da acceso a  todos los menús de  Emacs, menu, archivo,
edición, cambio entre las distintas ventanas de edición de texto, etc.

Empecemos viendo cómo editar un fichero de texto básico. En la consola
ponemos:

\begin{verbatim}
$ emacs hola.c
\end{verbatim}

y escribe un programa común y corto:

\begin{verbatim}
#include <stdio.h>
int
main()
{
  printf("\nHola Mundo\n\n");
}
\end{verbatim}

Como podrás  apreciar, Emacs hace  retroceder el cursor al  cerrar los
corchetes y los paréntesis, para  indicarnos dónde los abrimos y tener
una  referencia de  cuáles quedan  aún  por cerrar.  Probemos ahora  a
guardar nuestro pequeño programa C. Para ello pulsamos {\tt F10} y una
vez pulsada {\tt F10}  vemos que la tecla {\tt B}  nos daría acceso al
menú buffers  (que no  son otra  cosa que  las distintas  ventanas que
tenemos abiertas), la {\tt F} nos daría acceso al menú {\tt files} (el
cual  hace prácticamente  lo mismo  que el  menú archivo  de cualquier
editor de texto,  etc\dots \ y la  tecla {\tt C} nos  daría acceso, si
las tenemos instaladas,  a las posibilidades que ofrece  emacs para la
edición de código  en C. Como sólo queremos  guardar, pulsamos después
de  {\tt F10},  {\tt  S}. Ya  lo tendríamos  guardado.  Otra cosa  muy
importante, en  cualquier programa  es saber salir.  Esto se  hace con
{\tt F10}, {\tt F} y a continuación la tecla {\tt E}. Nos pregunta, si
no lo  hemos hecho ya, que  si deseamos guardar. Escribimos  {\tt yes}
(hay que escribirlo entero) o {\tt  no}, y a continuación nos pregunta
si realmente queremos salir, a lo cual ahora sí, responderemos {\tt y}
para {\tt sí} o {\tt n} para {\tt no}.

Emacs  es famoso  por sus  innumerables combinaciones  de teclas  para
realizar  cualquiera de  las operaciones  que ofrece.  Algunas de  las
combinaciones de  teclas para  moverse cómodamente por  los documentos
son:

\begin{table}[htbp]
\centering
\begin{tabular}{|c|l|}
\hline
{\tt A-f  } & Sitúa el cursor al principio de la palabra siguiente. \\
{\tt A-b  } & Sitúa el cursor al principio de la palabra anterior. \\
{\tt C-a  } & Sitúa el cursor al principio de la línea actual. \\
{\tt C-e  } & Sitúa el cursor al final de la línea actual. \\
{\tt A-a  } & Retrocede el cursor hasta el principio de la frase. \\
{\tt A-e  } & Avanza el cursor hasta el final de la frase. \\
{\tt Home } & Nos permite situarnos al principio del "buffer". \\
{\tt End  } & Nos permite situarnos al final del "buffer". \\
{\tt C-l  } & Sitúa el cursor justo al principio de la línea del medio de la pantalla \\
\hline
\end{tabular}
\caption{Combinaciones de teclas para moverse con GNU Emacs}
\end{table}

Algunas teclas para eliminar texto:

\begin{table}[htbp]
\centering
\begin{tabular}{|c|l|}
\hline
{\tt A-d }      & Elimina la palabra que sigue al cursor. \\
{\tt A-delete } & Elimina la palabra anterior al cursor. \\
{\tt C-k }      & Elimina la línea actual entera. \\
{\tt A-k }      & Elimina la frase siguiente \\
{\tt C-x + BackSpace } & Elimina la frase anterior \\
\hline
\end{tabular}
\caption{Combinaciones de teclas para borrar texto con GNU Emacs}
\end{table}

Hay que añadir un truco bastante  útil que es la combinación de teclas
{\tt C-u}, la cual nos permite repetir cualquier comando n veces.

Por  ejemplo, si  quisiéramos  avanzar 24  palabras, utilizaríamos  la
secuencia de teclas {\tt C-u 24 A-f}

Otra función  muy básica también es  la de buscar y  reemplazar texto.
Esto  puede hacerse  cómodamente con  la  combinación {\tt  C-s}, y  a
continuación poniendo que queremos buscar  y pulsando {\tt Enter}. Una
vez encuentre  la primera coin\-ci\-den\-cia, puede  seguir buscándose
el mismo patrón pulsando de nuevo simplemente {\tt C-s}.

Podemos saber  en todo momento  qué estamos haciendo fijándonos  en la
línea inferior de la pantalla de Emacs.

Para  reemplazar  trozos  de  texto, cosa  también  de  supervivencia,
podemos hacerlo fácilmente de la siguiente forma:

\begin{enumerate}
\item Pulsamos {\tt F10}
\item Pulsamos la S, que corresponde al menú Search
\item Nos sale el siguiente menú:
\end{enumerate}

\begin{verbatim}
Possible completions are:
S==\frq Search...                      R==\frq Regexp Search...
B==\frq Search Backwards...            0==\frq Regexp Search Backwards...
1==\frq Repeat Search                  2==\frq Repeat Regexp
3==\frq Repeat Backwards               4==\frq Repeat Regexp Backwards
5==\frq Bookmarks                      F==\frq Find Tag...  (M-.)
Q==\frq Query Replace...  (M-%)        6==\frq Query Replace Regexp...
\end{verbatim}

Pulsamos {\tt Q} y nos dice:

{\tt Query  replace:} donde escribiremos  lo que queremos  buscar para
ser reemplazado, y pulsamos {\tt Enter}.

Luego,  emacs  nos   pregunta:  {\tt  query  replace   with:  }  donde
escribiremos el  texto con  el cual  queremos sustituir,  y pulsaremos
enter.

En este  menú, encontramos  también una serie  de comandos,  como {\tt
query  regexp},  {\tt  query  replace regexp},  etc.,  que  aunque  no
entraremos en ellos,  son muy interesantes, pues  nos permiten buscar,
no  ya patrones  de  texto concretos,  sino un  tipo  de búsqueda  más
avanzada por medio de expresiones regulares ({\bf regular expressions}
en  inglés), esto  es,  ``todas  las palabras  que  empiecen  por c  y
terminen por j'' o ``todas  las mayúsculas cambiarlas por minúsculas''
en el caso de {\tt query replace regexp}.

Insertando un fichero de texto en nuestro documento:

Para  los amantes  del Cut  \& Pasting  (un deporte  muy extendido  en
algunos círculos de programadores), aquí va un comando que nos permite
introducir un documento de texto dentro de otro:

Pulsamos {\tt C-x}, seguido de la {\tt i}, para insertar un fichero en
la posición  actual del cursor. Entonces,  en la línea de  comandos de
emacs, aparecerá el directorio actual.

Escribimos  la ruta  completa al  archivo y  aparecerá en  la posición
actual del cursor.

\section{Joe}

\index{Joe}

El primer editor  que suele aprenderse en Linux es  {\sf Joe}, por ser
muy sencillo  y rápido.  Puede usarse  para editar  cualquier fichero,
pero  aquí trataremos  su uso  básico, lo  justo para  editar pequeños
textos,  ficheros de  configuración, pequeños  programas. Todos  estos
ficheros pueden editarse  con más comodidad con  editores más potentes
como {\sf  Emacs} o {\sf VIM}  pero para ello es  necesario aprender a
usarlos primero, lo cual puede  no resultar tan sencillo como aprender
{\sf Joe}.

Veremos sólo un par de comandos  de {\sf Joe}, simplemente como editar
un fichero existente o nuevo, guardarlo sin salir, salir sin guardarlo
y salir guardándolo. Para obtener más información sobre otras opciones
del editor existe el comando de ayuda que explicaremos luego.

El manejo de {\tt Joe} se basa en combinaciones de teclas con la tecla
{\tt Control}. Denotaremos por {\tt C-x  y} a la combinación de teclas
que se  obtiene al  pulsar la tecla  {\tt Control},  seguidamente (sin
soltar la  primera) pulsar la  tecla {\tt  x} y después  (soltando las
teclas anteriores) pulsar  la tecla {\tt y}. Veamos  un rápido ejemplo
del uso de este editor. En un terminal ejecuta:

\begin{verbatim}
$ joe prueba.txt
\end{verbatim}

Escribe una frase sencilla, tal como:

\begin{verbatim}
Si algo funciona, no lo toques.
\end{verbatim}

Para guardar el  fichero utilizamos la combinación de  teclas {\tt C-k
s} y  entonces {\tt Joe}  te preguntará el  nombre con el  que quieres
guardar el fichero.

\begin{verbatim}
Name of file to save (^C to abort): hola.txt
\end{verbatim}

Si pulsamos ahora  ahora {\tt C-c} simplemente cancelamos  la orden de
guardar el  fichero, pero  no perdemos su  contenido. Para  guardar el
fichero pulsamos {\tt Enter}, modificando  el nombre del fichero si lo
deseamos. Ahora añadimos otra línea:

\begin{verbatim}
Si algo funciona, no lo toques.
Si algo funciona, y no sabes por qué, úsalo siempre.
\end{verbatim}

Ahora saldremos  del editor {\bf  guardando los cambios},  mediante la
combinación de teclas {\tt C-k x}. De esta manera volveremos al prompt
del sistema siendo informados de que el fichero ha sido guardado.

\begin{verbatim}
File prueba.txt saved.
$
\end{verbatim}

Como última maniobra, abrimos de  nuevo el fichero, borramos la última
línea y salimos sin guardar los cambios.


\begin{verbatim}
$ joe prueba.txt
\end{verbatim}

Borramos la  última línea  usando las teclas  de borrado  habituales, y
pulsamos {\tt C-c}  para salir sin guardar los cambios.  El editor nos
pedirá confirmación antes de salir.  Podemos responder que sí queremos
salir  pulsando {\tt  y},  o  por el  contrario  cancelar la  maniobra
pulsando {\tt n} o  {\tt C-c}. Decimos que sí ({\tt  y}) y volvemos al
prompt del sistema.

\begin{verbatim}
Lose changes to this file (y,n,^C)? 
File hola.txt not saved.
$
\end{verbatim}

Esto es  lo mínimo que  debes saber para editar  con {\tt Joe},  y con
esto  será suficiente  aquí pues  en  lo sucesivo  aprenderás a  hacer
operaciones más avanzadas con otros editores. Para conocer sobre otras
opciones de este editor, se puede utilizar la opción {\tt C-k h}.