57 KiB

Raw Blame History

Traducción Revisón: 1.70

GNU/Emacs 29.1

39 Ejecución de comandos de shell desde Emacs
Ver código fuente de la página

39 Ejecución de comandos de shell desde Emacs

Emacs tiene instrucciones para pasar líneas de comandos individuales a subprocesos de shell, y para ejecutar un shell interactivamente con entrada y salida a un búfer Emacs, y para ejecutar un shell en una ventana de emulador de terminal.

M-! cmd RET: Ejecuta el comando shell cmd y muestra la salida (shell-command).
M-| cmd RET: Ejecuta el comando shell cmd con el contenido de la región como entrada; opcionalmente sustituye la región por la salida (shell-command-on-region).
M-&: Ejecuta el comando de shell cmd de forma asíncrona y muestra la salida (async-shell-command).
M-x shell: Ejecuta un subshell con entrada y salida a través de un buffer Emacs. A continuación, puede dar órdenes de forma interactiva.
M-x term: Ejecuta un subshell con entrada y salida a través de un buffer Emacs. A continuación, puede dar órdenes de forma interactiva. Está disponible la emulación de terminal completa.

Siempre que se especifica un nombre de fichero relativo para un programa ejecutable (ya sea en el argumento cmd de uno de los comandos anteriores, o en otros contextos), Emacs busca el programa en los directorios especificados por la variable exec-path. El valor de esta variable debe ser una lista de directorios; el valor por defecto se inicializa a partir de la variable de entorno PATH cuando se inicia Emacs (ver Variables Generales).

M-x eshell invoca un shell implementado enteramente en Emacs. Está documentado en su propio manual. Ver Eshell en Eshell: The Emacs Shell.

39.1 Comandos de shell Simples

M-! (shell-command) lee una línea de texto usando el minibuffer y la ejecuta como un comando del shell, en un subshell hecho sólo para ese comando. La entrada estándar para el comando proviene del dispositivo null. Si el comando del shell produce alguna salida, ésta aparece en el área de eco (si es corta), o en el búfer “»Shell Command Output»” (shell-command-buffer-name) (si la salida es larga). Las variables resize-mini-windows y max-mini-window-height (ver Editar en el Minibúfer) controlan cuando Emacs debe considerar que la salida es demasiado larga para el área de eco. Tenga en cuenta que personalizar shell-command-dont-erase-buffer, descrito más adelante, puede afectar a lo que se muestra en el área de eco.

Por ejemplo, una forma de descomprimir un archivo llamado foo.gz es escribir M-! gunzip foo.gz RET. Este comando del shell normalmente crea el archivo foo y no produce ninguna salida en el terminal.

Un argumento numérico para shell-command, por ejemplo, M-1 M-!, hace que inserte la salida del terminal en el búfer actual en lugar de en un búfer separado. Por defecto, pone el punto antes de la salida, y pone la marca después de la salida (pero un valor no predeterminado de shell-command-dont-erase-buffer puede cambiar esto, ver más abajo). Por ejemplo, M-1 M-! gunzip < foo.gz RET insertaría la forma descomprimida del archivo foo.gz en el búfer actual.

Siempre que el comando de shell especificado no termine con “&”, se ejecuta de forma sincrónica, y debes esperar a que salga antes de continuar usando Emacs. Para dejar de esperar, teclea C-g para salir; esto envía una señal SIGINT para terminar el comando shell (es la misma señal que C-c genera normalmente en el shell). Emacs entonces espera hasta que el comando realmente termina. Si el comando de la shell no se detiene (porque ignora la señal SIGINT), teclea C-g de nuevo; esto envía al comando una señal SIGKILL, que es imposible de ignorar.

Un comando shell que termina en “&” se ejecuta asíncronamente, y puede continuar usando Emacs mientras se ejecuta. También puede escribir M-& (async-shell-command) para ejecutar un comando de shell asíncrono; esto es exactamente como llamar a M-! con un “&” al final, excepto que no necesita el “&”. La salida de los comandos de shell asíncronos, por defecto, va al buffer “»Async Shell Command»” (shell-command-buffer-name-async). Emacs inserta la salida en este búfer a medida que llega, tanto si el búfer es visible en una ventana como si no.

Si desea ejecutar más de un comando de shell asíncrono al mismo tiempo, podrían acabar compitiendo por el búfer de salida. La opción async-shell-command-buffer especifica qué hacer al respecto; por ejemplo, si renombrar el búfer de salida preexistente, o utilizar un búfer diferente para el nuevo comando. Consulte la documentación de la variable para más posibilidades.

Si desea que el búfer de salida de las órdenes asíncronas se muestre sólo cuando la orden genere salida, establezca async-shell-command-display-buffer a nil.

La opción async-shell-command-width define el número de columnas de visualización disponibles para la salida de comandos del shell asíncrono. Un número entero positivo indica al shell que utilice ese número de columnas para la salida de comandos. El valor predeterminado es nil, que significa utilizar el mismo número de columnas que proporciona el shell.

Para que los comandos anteriores muestren el directorio actual en sus avisos, personalice la variable shell-command-prompt-show-cwd con un valor distinto de nil.

M-| (shell-command-on-region) es como M-!, pero pasa el contenido de la región como la entrada estándar al comando del shell, en lugar de ninguna entrada. Con un argumento numérico, borra la región antigua y la sustituye por la salida del comando de la shell.

Por ejemplo, puede utilizar M-| con el programa gpg para ver qué claves hay en el búfer. Si el búfer contiene una clave GnuPG, escriba C-x h M-| gpg RET para enviar todo el contenido del búfer a gpg. Esto mostrará la lista de claves en el búfer cuyo nombre es el valor de shell-command-buffer-name.

Los comandos anteriores utilizan el intérprete de órdenes especificado por la variable shell-file-name. Su valor por defecto viene determinado por la variable de entorno SHELL cuando se inicia Emacs. Si el nombre del fichero es relativo, Emacs busca en los directorios listados en exec-path (ver Ejecutando Comandos shell desde Emacs).

Si el directorio por defecto es remoto (ver Archivos Remotos), el valor por defecto es /bin/sh. Esto puede cambiarse declarando shell-file-name connection-local (ver Variables Locales Por-Conexión).

Para especificar un sistema de codificación para M-! o M-|, utilice el comando C-x RET c inmediatamente antes. Consulte Sistemas de Codificación para la Comunicación entre Procesos.

Por defecto, la salida de errores se mezcla con la salida normal en el búfer de salida. Pero si cambia el valor de la variable shell-command-default-error-buffer a una cadena, la salida de error se inserta en un búfer con ese nombre.

Por defecto, el búfer de salida se borra entre comandos del shell, excepto cuando la salida va al búfer actual. Si cambia el valor de la opción shell-command-dont-erase-buffer a erase, el búfer de salida se borra siempre. Otros valores no nulos evitan el borrado del búfer de salida, y -si el búfer de salida no es el búfer actual- también controlan dónde poner el punto después de insertar la salida del comando shell:

beg-last-out: Sitúa el punto al principio de la última salida del comando shell.
end-last-out: Coloca el punto al final de la última salida del comando shell, es decir, al final del búfer de salida.
save-point: Restaura la posición del punto tal y como estaba antes de insertar la salida del comando shell.

Tenga en cuenta que si esta opción no es nula, la salida mostrada en el área de eco podría ser de más de la última orden, ya que el área de eco sólo muestra una parte del búfer de salida.

En caso de que el búfer de salida no sea el búfer actual, la salida del comando shell se añade al final de este búfer.

39.2 Subshell Interactiva

Para ejecutar un subproceso interactivamente, escriba M-x shell. Esto crea (o reutiliza) un buffer llamado shell, y ejecuta un subproceso shell con entrada proveniente de y salida hacia ese buffer. Es decir, cualquier salida de terminal del subproceso va al búfer, avanzando un punto, y cualquier entrada de terminal para el subproceso proviene del texto del búfer. Para dar entrada a la subshell, vaya al final del buffer y escriba la entrada, terminada por RET.

Por defecto, cuando la subshell es invocada interactivamente, el shell buffer es mostrado en una nueva ventana, a menos que la ventana actual ya muestre el shell buffer. Este comportamiento puede personalizarse mediante display-buffer-alist (ver Cómo Trabaja display-buffer).

Mientras la subshell está esperando o ejecutando un comando, puede cambiar de ventana o de búfer y realizar otras ediciones en Emacs. Emacs inserta la salida del subshell en el buffer Shell siempre que tiene tiempo para procesarla (por ejemplo, mientras espera la entrada del teclado).

En el buffer de Shell, los prompts se muestran con la cara comint-highlight-prompt, y las líneas de entrada enviadas se muestran con la cara comint-highlight-input. Esto facilita distinguir las líneas de entrada de la salida del intérprete de comandos. Véase Caras de Texto.

Para hacer múltiples subshells, invoque M-x shell con un argumento prefijo (por ejemplo, C-u M-x shell). Entonces el comando leerá un nombre de buffer, y creará (o reutilizará) un subshell en ese buffer. También puede cambiar el nombre del búfer shell utilizando M-x rename-uniquely, y luego crear un nuevo búfer shell utilizando M-x shell simple. Las subcarpetas en diferentes buffers se ejecutan independientemente y en paralelo.

Emacs intenta hacer un seguimiento de cuál es el directorio actual mirando los comandos que se introducen, buscando comandos “cd” y similares. Esta es una solución propensa a errores, ya que hay muchas maneras de cambiar el directorio actual, por lo que Emacs también busca códigos de escape OSC (Operating System Commands, Comandos del Sistema Operativo) especiales que están diseñados para transmitir esta información de una manera más fiable. Debe hacer que su shell imprima la secuencia de escape apropiada en cada prompt, por ejemplo con el siguiente comando:

printf «e]7;file://%s%se\» «$HOSTNAME» «$PWD»

Para especificar el nombre del fichero shell usado por M-x shell, personaliza la variable explicit-shell-file-name. Si es nil (por defecto), Emacs usa la variable de entorno ESHELL si existe. Si no, normalmente usa la variable shell-file-name (ver Comandos de shell Single); pero si el directorio por defecto es remote (ver Archivos Remotos), te pregunta por el nombre del archivo de shell. Ver Minibúferes para nombres de ficheros, para pistas sobre cómo escribir nombres de archivos remotos de forma efectiva.

Emacs envía a la nueva shell el contenido del fichero ~/.emacs_nombre_shell como entrada, si existe, donde nombre_shell es el nombre del fichero desde el que se cargó la shell. Por ejemplo, si usa bash, el archivo que se le envía es ~/.emacs_bash. Si este fichero no se encuentra, Emacs lo intenta con ~/.emacs.d/init_shellname.sh.

Para especificar un sistema de codificación para la shell, puede usar el comando C-x RET c inmediatamente antes de M-x shell. También puede cambiar el sistema de codificación para un subshell en ejecución escribiendo C-x RET p en el buffer del shell. Véase Sistemas de Codificación para la Comunicación Interproceso.

Emacs establece la variable de entorno INSIDE_EMACS en la subshell a “version,comint”, donde version es la versión de Emacs (por ejemplo, “28.1”). Los programas pueden comprobar esta variable para determinar si se están ejecutando dentro de una subshell de Emacs.

39.3 Modo Shell

El modo principal para los búferes de Shell es el modo Shell. Muchos de sus comandos especiales están ligados al prefijo C-c, y se asemejan a los caracteres habituales de edición y control de trabajos presentes en los shells ordinarios, excepto que primero debe teclear C-c. He aquí una lista de comandos del modo Shell:

RET: Envía la línea actual como entrada a la subshell (comint-send-input). Se omite cualquier petición de la shell al principio de la línea (véase Peticiones de la shell). Si el punto está al final del búfer, esto es como enviar la línea de comandos en un shell interactivo ordinario. Sin embargo, también puede invocar RET en cualquier parte del búfer de la shell para enviar la línea actual como entrada.
TAB: Completa el nombre del comando o del fichero antes del punto en el buffer de la shell (completion-at-point). Esto usa las reglas de completado habituales de Emacs (ver Completado), con las alternativas de completado siendo nombres de archivo, nombres de variables de entorno, el historial de comandos del shell y referencias al historial (ver Referencias al Historial del Shell). Para las opciones que controlan el completado, vea Opciones del Modo Shell.
M-?: Muestra temporalmente una lista de las posibles terminaciones del nombre de archivo antes del punto (comint-dynamic-list-filename-completions).
C-d: Borra un carácter o envía EOF (comint-delchar-or-maybe-eof). Si se escribe al final del búfer de la shell, se envía EOF a la subshell. Si se escribe en cualquier otra posición del búfer, se borra un carácter de la forma habitual.
C-c C-a: Se mueve al principio de la línea, pero después del prompt si lo hay (comint-bol-o-marca-de-proceso). Si repite este comando dos veces seguidas, la segunda vez se mueve de nuevo a la marca de proceso, que es el principio de la entrada que todavía no ha enviado a la subshell. (Normalmente ese es el mismo lugar-el final del prompt en esta línea-pero después de C-c SPC la marca de proceso puede estar en una línea anterior).
C-c SPC: Acumula varias líneas de entrada y las envía juntas (comint-accumulate). Este comando inserta una nueva línea antes del punto, pero no envía el texto precedente como entrada al subshell-al menos, no todavía. Ambas líneas, la anterior a esta nueva línea y la posterior, se enviarán juntas (junto con la nueva línea que las separa), cuando escriba RET.
C-c C-u: Mata todo el texto pendiente al final del buffer para ser enviado como entrada (comint-kill-input). Si el punto no está al final del búfer, esto sólo mata la parte de este texto que precede al punto.
C-c C-w: Mata una palabra antes del punto (backward-kill-word).
C-c C-c: Interrumpe el shell o su subjob (proceso hijo) actual, si existe (comint-interrupt-subjob). Este comando también elimina cualquier entrada del intérprete de órdenes pendiente en el búfer del intérprete de órdenes y aún no enviada.
C-c C-z: Detiene el shell o su subjob (proceso hijo) actual si existe (comint-stop-subjob). Este comando también elimina cualquier entrada del intérprete de órdenes pendiente en el búfer del intérprete de órdenes y aún no enviada.
C-c C-: Envía una señal de salida al shell o a su subjob (proceso hijo) actual si existe (comint-quit-subjob). Este comando también mata cualquier entrada del shell pendiente en el búfer del shell y aún no enviada.
C-c C-o: Borra el último lote de salida de un comando shell (comint-delete-output). Esto es útil si un comando de shell arroja mucha salida que simplemente estorba. Con un prefijo como argumento, este comando guarda el texto borrado en el kill-ring (ver The Kill Ring), de forma que más tarde pueda borrarlo (ver Yanking) en otro lugar.
C-c C-s: Escribe el último lote de salida de un comando del shell en un archivo (comint-write-output). Con un argumento prefijo, en su lugar se añade el archivo. Cualquier prompt al final de la salida no se escribe.

C-c C-r C-M-l

Se desplaza para mostrar el principio del último lote de salida en la parte superior de la ventana; también desplaza el cursor hasta allí (comint-show-output).

C-c C-e

Se desplaza para colocar la última línea del búfer en la parte inferior de la ventana (comint-show-maximum-output).

C-c C-f

Avanza un comando del shell, pero no más allá de la línea actual (shell-forward-command). La variable shell-command-regexp especifica cómo reconocer el final de un comando.

C-c C-b

Retrocede un comando del shell, pero no más allá de la línea actual (shell-backward-command).

M-x dirs

Pregunta al shell por su directorio de trabajo, y actualiza el directorio por defecto del buffer Shell. Véase Seguimiento de Directorios.

M-x comint-send-invisible RET texto RET ¶

Envía texto como entrada al shell, después de leerlo sin hacer eco. Esto es útil cuando un comando del shell ejecuta un programa que pide una contraseña.

Tenga en cuenta que Emacs no hará eco de las contraseñas por defecto. Si realmente quiere que se hagan eco, evalúe (vea Evaluando Expresiones Lisp de Emacs) la siguiente expresión Lisp:

(remove-hook “comint-output-filter-functions: “comint-watch-for-password-prompt)

M-x comint-continue-subjob

Continúa el proceso shell. Esto es útil si accidentalmente suspende el proceso shell.22

M-x comint-strip-ctrl-m

Descarta todos los caracteres control-M del grupo actual de salida del shell. La forma más cómoda de utilizar este comando es hacer que se ejecute automáticamente cuando obtenga la salida del subshell. Para ello, evalúe esta expresión Lisp:

(add-hook “comint-output-filter-functions
“comint-strip-ctrl-m)

M-x comint-truncate-buffer

Este comando trunca el búfer del shell a un cierto número máximo de líneas, especificado por la variable comint-buffer-maximum-size. A continuación se muestra cómo hacer esto automáticamente cada vez que se obtiene salida de la subshell:

(add-hook “comint-output-filter-functions
“comint-truncate-buffer)

Por defecto, el modo Shell maneja los códigos de escape ANSI comunes (por ejemplo, para cambiar el color del texto). Emacs también soporta opcionalmente algunos códigos de escape extendidos, como algunos de los OSC (Operating System Codes, Códigos del Sistema Operativo) si pone lo siguiente en su fichero init:

(add-hook “comint-output-filter-functions “comint-osc-process-output)

Con esta opción activada, la salida de, por ejemplo, ls –hyperlink se convertirá en botones clicables en el búfer del modo Shell.

El modo Shell es un derivado del modo Comint, un modo de propósito general para comunicarse con subprocesos interactivos. La mayoría de las características del modo Shell provienen en realidad del modo Comint, como se puede ver en los nombres de los comandos listados anteriormente. Las características especiales del modo Shell incluyen la característica de rastreo de directorios, y algunos comandos de usuario.

Otras características de Emacs que usan variantes del modo Comint incluyen GUD (ver Ejecutando depuradores bajo Emacs) y M-x run-lisp (ver Ejecutando un Lisp externo).

Puede usar M-x comint-run para ejecutar cualquier programa de su elección en un subproceso usando el modo Comint sin modificar -sin las especializaciones del modo Shell. Para pasar argumentos al programa, utilice C-u M-x comint-run.

No debe suspender el proceso del shell. Suspender un subjob (proceso hijo) del shell es un asunto completamente diferente, es una práctica normal, pero debe usar el shell para continuar el subjob; este comando no lo hará.

39.4 Avisos de Shell

Un prompt es la salida de texto de un programa para mostrar que está listo para aceptar nuevas entradas del usuario. Normalmente, el modo Comint (y por tanto el modo Shell) calcula automáticamente qué parte del buffer es un prompt, basándose en la salida del subproceso. (Específicamente, asume que cualquier línea de salida recibida que no termine con una nueva línea es un prompt).

El modo Comint divide el buffer en dos tipos de campos: campos de entrada (donde se teclea la entrada del usuario) y campos de salida (en todos los demás lugares). Los prompt forman parte de los campos de salida. La mayoría de los comandos de movimiento de Emacs no cruzan los límites de los campos, a menos que se muevan por varias líneas. Por ejemplo, cuando punto está en el campo de entrada en una línea de comandos de shell, C-a pone punto al principio del campo de entrada, después del prompt. Internamente, los campos se implementan usando la propiedad de texto de campo (ver Propiedades de Texto en el Manual de Referencia de Emacs Lisp).

Si cambia la variable comint-use-prompt-regexp a un valor no nulo, el modo Comint reconocerá los avisos utilizando una expresión regular (véase Sintaxis de Expresiones Regulares). En el modo Shell, la expresión regular se especifica mediante la variable shell-prompt-pattern. El valor por defecto de comint-use-prompt-regexp es nil, porque este método para reconocer prompts no es fiable, pero puede que quiera establecerlo a un valor no nil en circunstancias inusuales. En ese caso, Emacs no divide el búfer Comint en campos, por lo que los comandos de movimiento generales se comportan como lo hacen normalmente en búferes sin propiedades de texto especiales. Sin embargo, puede usar los comandos de movimiento de párrafo para navegar convenientemente por el buffer (ver Párrafos); en modo Shell, Emacs usa shell-prompt-pattern como límites de párrafo.

39.5 Historial de Órdenes del Shell

Los búferes del intérprete de órdenes admiten tres formas de repetir órdenes anteriores. Puede usar teclas como las usadas para el historial del minibuffer; éstas funcionan de forma muy parecida a como lo hacen en el minibúfer, insertando texto de comandos anteriores mientras el punto permanece siempre al final del búfer. Puede moverse por el búfer hasta las entradas anteriores en su lugar original, y luego volver a enviarlas o copiarlas al final. ¡O puede utilizar una referencia histórica al estilo “!

39.5.1 Anillo del Historial de Shell

M-p C-UP

Recupera el comando shell anterior siguiente (comint-previous-input).

M-n C-DOWN

Obtiene el siguiente comando shell anterior (comint-next-input).

M-r: Inicia una búsqueda incremental de expreg (expesiones regulares) de antiguos comandos del shell (comint-history-isearch-backward-regexp).
C-c C-x: Obtiene la siguiente orden del historial (comint-get-next-from-history).
C-c .: Obtiene un argumento de un comando shell anterior (comint-input-previous-argument).
C-c C-l: Muestra el historial de comandos de shell del búfer en otra ventana (comint-dynamic-list-input-ring).

Los búferes de shell proporcionan un historial de los comandos de shell introducidos anteriormente. Para reutilizar comandos de shell del historial, utilice los comandos de edición M-p, M-n y M-r. Funcionan de forma similar a los comandos del historial del minibúfer (consulte Historial del Minibúfer), excepto que operan dentro del búfer del intérprete de comandos en lugar de hacerlo en el minibúfer, y M-r en un búfer del intérprete de comandos invoca la búsqueda incremental a través del historial de comandos del intérprete de comandos.

M-p recupera un comando del shell anterior hasta el final del búfer del shell. El uso sucesivo de M-p recupera sucesivamente comandos anteriores de la shell, cada uno reemplazando cualquier texto que ya estuviera presente como entrada potencial de la shell. M-n hace lo mismo, excepto que encuentra sucesivamente comandos más recientes del búfer. C-UP funciona como M-p, y C-DOWN como M-n.

El comando de búsqueda en el historial M-r inicia una búsqueda incremental de expresiones regulares en comandos anteriores del shell. Después de escribir M-r, comience a escribir la cadena o expresión regular deseada; el último comando del shell que coincida se mostrará en la línea actual. Los comandos de búsqueda incremental tienen sus efectos habituales; por ejemplo, C-s y C-r buscan hacia delante y hacia atrás la siguiente coincidencia (consulte Búsqueda Incremental). Cuando encuentre la entrada deseada, escriba RET para finalizar la búsqueda. Esto coloca la entrada en la línea de comandos. Cualquier entrada parcial que estuviera componiendo antes de navegar por la lista del historial se restaura cuando va al principio o al final del anillo del historial.

A menudo es útil reejecutar varios comandos sucesivos del shell que se ejecutaron previamente en secuencia. Para ello, primero busque y vuelva a ejecutar el primer comando de la secuencia. A continuación, escriba C-c C-x para obtener el siguiente comando, el que sigue al que acaba de repetir. A continuación, escribe RET para volver a ejecutar este comando. Puedes volver a ejecutar varios comandos sucesivos escribiendo C-c C-x RET una y otra vez.

El comando C-c . (comint-insert-previous-argument) copia un argumento individual de un comando anterior, como ESC . en Bash y zsh. El uso más simple copia el último argumento del comando shell anterior. Con un argumento prefijo n, copia el enésimo argumento en su lugar. Repetir C-c . copia desde un comando shell anterior, siempre usando el mismo valor de n (no des un argumento prefijo cuando repitas el comando C-c .).

Si establece comint-insert-previous-argument-from-end a un valor no nulo, C-c . copiará en su lugar el enésimo argumento contando desde el último; esto emula ESC . en zsh.

Estos comandos obtienen el texto de comandos anteriores del intérprete de comandos de una lista especial del historial, no del propio búfer del intérprete de comandos. Por lo tanto, editar el búfer del intérprete de comandos, o incluso eliminar grandes partes del mismo, no afecta al historial al que acceden estos comandos.

Algunas shell almacenan sus historiales de órdenes en archivos para que pueda consultar órdenes de sesiones anteriores de la shell. Emacs lee el fichero de historial de comandos de la shell elegida, para inicializar su propio historial de comandos. El nombre del fichero es ~/.bash_history para bash, ~/.sh_history para ksh, y ~/.history para otras shell.

Si ejecuta el intérprete de comandos en un host remoto, la variable tramp-histfile-override puede sobrescribir esta configuración. Se recomienda establecer esta variable en nil.

39.5.2 Copiar el Historial del Shell

C-c C-p: Mueve el punto al prompt anterior (comint-previous-prompt).
C-C C-n: Mueve el punto al siguiente prompt (comint-next-prompt).
C-c RET: Copia el comando de entrada en el punto, insertando la copia al final del buffer (comint-copy-old-input). Esto es útil si desplaza el punto a un comando anterior. Después de copiar el comando, puede enviar la copia como entrada con RET. Si lo desea, puede editar la copia antes de volver a enviarla. Si usa este comando en una línea de salida, copia esa línea al final del buffer.
ratón-2: Si comint-use-prompt-regexp es nil (por defecto), copia el comando de entrada antiguo sobre el que se hace clic, insertando la copia al final del buffer (comint-insert-input). Si comint-use-prompt-regexp no es nil, o si el clic no es sobre la entrada antigua, simplemente tira como de costumbre.

Desplazarse a una entrada anterior y luego copiarla con C-c RET o ratón-2 produce los mismos resultados -el mismo contenido del búfer,- que obtendría utilizando M-p suficientes veces para recuperar esa entrada anterior de la lista del historial. Sin embargo, C-c RET copia el texto del búfer, que puede ser diferente de lo que hay en la lista del historial si edita el texto de entrada en el búfer después de haberlo enviado.

39.5.3. Referencias al Historial del Shell

Varios shells, incluyendo csh y bash, soportan referencias históricas que comienzan con “!” y “^”. El modo Shell reconoce estas construcciones y puede realizar la sustitución del historial por Usted.

Si inserta una referencia histórica y teclea TAB, se buscará en el historial de entrada un comando que coincida, se realizará la sustitución si es necesario, y se colocará el resultado en el búfer en lugar de la referencia histórica. Por ejemplo, puede buscar la orden más reciente que empiece por “mv” con ! m v TAB. Si lo desea, puede editar la orden y, a continuación, volver a enviarla al intérprete de comandos escribiendo RET.

El modo shell puede expandir opcionalmente las referencias del historial en el búfer cuando las envía al shell. Para ello, establezca la variable comint-input-autoexpand en input. Puede hacer que SPC realice la expansión del historial vinculando SPC al comando comint-magic-space. Consulte Cambio Interactivo de Combinaciones de Teclas.

El modo Shell reconoce las referencias al historial cuando siguen a un prompt. Consulte Avisos de Shell, para ver cómo el modo Shell reconoce los avisos.

39.6 Seguimiento de Directorios

El modo Shell realiza un seguimiento de los comandos “cd”, “pushd” y “popd” dados al subshell, para mantener el directorio por defecto del búfer Shell (ver Nombres de Archivos) igual que el directorio de trabajo del shell. Reconoce estos comandos examinando las líneas de entrada que envías.

Si usa alias para estos comandos, puede decirle a Emacs que los reconozca también, estableciendo las variables shell-pushd-regexp, shell-popd-regexp, y shell-cd-regexp a las expresiones regulares apropiadas (vea Sintaxis de Expresiones Regulares). Por ejemplo, si shell-pushd-regexp coincide con el principio de una línea de comandos del shell, esa línea se considera un comando pushd. Estos comandos sólo se reconocen al principio de una línea de comandos del shell.

Si Emacs se confunde con los cambios en el directorio de trabajo del subshell, escriba M-x dirs. Este comando pregunta al shell por su directorio de trabajo y actualiza el directorio por defecto en consecuencia. Funciona para shells que soportan la sintaxis de comandos más común, pero puede no funcionar para shells poco comunes.

También puede utilizar el modo Dirtrack, un modo menor de búfer local que implementa un método alternativo de seguimiento del directorio de trabajo del intérprete de comandos. Para utilizar este método, el prompt de su shell debe contener el directorio de trabajo en todo momento, y debe proporcionar una expresión regular para reconocer qué parte del prompt contiene el directorio de trabajo; consulte la documentación de la variable dirtrack-list para más detalles. Para utilizar el modo Dirtrack, escriba M-x dirtrack-mode en el buffer de Shell, o añada dirtrack-mode a shell-mode-hook (ver Ganchos).

39.7 Opciones del Modo Shell

Si la variable comint-scroll-to-bottom-on-input es distinta de nil, los comandos de inserción y yank desplazan la ventana seleccionada hasta el final antes de insertar. El valor por defecto es nulo.

Si comint-scroll-show-maximum-output es no nil, la llegada de la salida cuando el punto está al final intenta desplazar la última línea de texto hasta la línea inferior de la ventana, mostrando tanto texto útil como sea posible. (Esto imita el comportamiento de desplazamiento de la mayoría de los terminales.) El valor por defecto es t.

Configurando comint-move-point-for-output, puede optar por que point salte al final del buffer cuando llegue la salida - sin importar en qué punto del buffer estaba antes. Si el valor es this, el punto salta en la ventana seleccionada. Si el valor es all, el punto salta en cada ventana que muestre el buffer Comint. Si el valor es other, el punto salta en todas las ventanas no seleccionadas que muestren el búfer actual. El valor por defecto es nil, lo que significa que el punto no salta al final.

Si establece comint-prompt-read-only, las indicaciones en el búfer Comint son de sólo lectura.

La variable comint-input-ignoredups controla si se almacenan entradas idénticas sucesivas en el historial de entradas. Un valor no nulo significa omitir una entrada que sea igual a la entrada anterior. El valor por defecto es nil, que significa almacenar cada entrada incluso si es igual a la entrada anterior.

Tres variables personalizan el completado del nombre de archivo. La variable comint-completion-addsuffix controla si el completado inserta un espacio o una barra para indicar un nombre de fichero o directorio completamente completado (no nil significa insertar un espacio o una barra). comint-completion-recexact, si no es nil, indica a TAB que elija el completado más corto posible si el algoritmo de completado habitual de Emacs no puede añadir ni un solo carácter. comint-completion-autolist, si no es nil, indica que se listen todos los completados posibles siempre que el completado no sea exacto.

La terminación de comandos normalmente sólo considera los archivos ejecutables. Si establece shell-completion-execonly a nil, considera también los archivos no ejecutables.

La variable shell-completion-fignore especifica una lista de extensiones de nombres de archivo a ignorar en el completado en modo Shell. El valor predeterminado es nil, pero algunos Usuarios prefieren («~» «#» «%») ignorar los nombres de archivo que terminan en “~”, “#” o “%”. Otros modos Comint relacionados utilizan la variable comint-completion-fignore en su lugar.

También se pueden encontrar algunos detalles de implementación de la finalización de órdenes del shell en la documentación lisp de la función shell-dynamic-complete-command.

Puede configurar el comportamiento de “pushd”. Las variables controlan si “pushd” se comporta como “cd” si no se da ningún argumento (shell-pushd-tohome), pop en lugar de rotate con un argumento numérico (shell-pushd-dextract), y sólo añade directorios a la pila de directorios si no están ya en ella (shell-pushd-dunique). Los valores que elija deben coincidir con el shell subyacente, por supuesto.

El modo Comint establece la variable de entorno TERM a un valor por defecto seguro, pero este valor deshabilita algunas características útiles. Por ejemplo, el color está deshabilitado en las aplicaciones que usan TERM para determinar si se admite el color. Por lo tanto, Emacs proporciona una opción comint-terminfo-terminal que le permite elegir un terminal con características más avanzadas, como se define en la base de datos terminfo de su sistema. Emacs usará esta opción como el valor de TERM siempre que system-uses-terminfo no sea nulo.

Tanto comint-terminfo-terminal como system-uses-terminfo pueden declararse como variables connection-local para ajustar estas opciones a lo que espera un sistema remoto (ver Variables Locales por Conexión).

39.8 Emulador de Terminal Emacs

Para ejecutar un subshell en un emulador de terminal de texto, use M-x term. Esto crea (o reutiliza) un buffer llamado terminal, y ejecuta un subshell con la entrada proveniente de su teclado, y la salida va a ese buffer.

El emulador de terminal utiliza el modo Term, que tiene dos modos de entrada. En modo línea, Term básicamente actúa como el modo Shell (ver Modo Shell). En el modo char, cada carácter se envía directamente al subshell, como entrada de terminal; la única excepción es el carácter de escape de terminal, que por defecto es C-c (ver Modo Term). Cualquier eco de su entrada es responsabilidad del subshell; cualquier salida terminal del subshell va al buffer, punto de avance.

Algunos programas (como Emacs mismo) necesitan controlar la apariencia de la pantalla del terminal en detalle. Lo hacen emitiendo códigos de control especiales. El modo Term reconoce y maneja secuencias de escape tipo VT100 estándar ANSI, que son aceptadas por la mayoría de los terminales modernos, incluyendo xterm. (Por lo tanto, puede ejecutar Emacs dentro de una ventana de Emacs Term. )

La cara de term (term face) especifica la apariencia predeterminada del texto en el emulador de terminal (la apariencia predeterminada es la misma que la cara predeterminada). Cuando se usan códigos de control de terminal para cambiar la apariencia del texto, estos se representan en el emulador de terminal con las caras term-color-black (term-color-negro), term-color-red (term-color-rojo), term-color-green (term-color-verde), term-color-yellow (term-color-amarillo), term-color-blue (term-color-azul), term-color-magenta, term-color-cyan, term-color-white (term-color-blanco), term-color-underline (term-color-subrayado), and term-color-bold (term-color-negrita). Ver Caras de Texto.

También puede usar el modo Term para comunicarse con un dispositivo conectado a un puerto serie. Consulte Terminal en Serie.

El nombre de archivo utilizado para cargar el subshell se determina de la misma manera que para el modo Shell. Para hacer múltiples emuladores de terminal, renombrar el buffer terminal a algo diferente usando M-x rename-uniquely, al igual que con el modo Shell.

A diferencia del modo Shell, el modo Term no realiza un seguimiento del directorio actual mediante el examen de su entrada. Pero algunos shells pueden decirle a Term cuál es el directorio actual. Esto se hace automáticamente con bash versión 1. 15 y posteriores.

39.9 Modo Term

Para cambiar entre modo línea y modo char en el modo Term, utilice estos comandos:

C-c c-j: Cambia al modo línea (term-line-mode). No hace nada si ya está en modo línea.
C-c C-k: Cambia al modo char (term-char-mode). No hace nada si ya está en modo char.

Los siguientes comandos sólo están disponibles en modo char:

C-c C-c: Envía un literal C-c a la subcarpeta (term-interrupt-subjob).
C-c caracter: Esto es equivalente a C-x char en Emacs normal. Por ejemplo, C-c o invoca el enlace global de C-x o, que normalmente es “other-window” (otra-ventana).

El modo Term tiene una función de página a página. Cuando está activada, hace que la salida se detenga al final de cada pantalla:

C-c C-q: Activa la función de página a página (term-pager-toggle). Este comando funciona tanto en modo línea como en modo char. Cuando la función está activada, la línea de modo muestra la palabra «página», y cada vez que Term recibe más de una pantalla de salida, hace una pausa y muestra «MORE» (MÁS) en la línea de modo. Escriba SPC para ver la siguiente pantalla llena, o ? para ver las demás opciones. La interfaz es similar a la del programa more.

39.10 Shell de Host Remoto

Puede conectarse a un ordenador remoto, utilizando cualquier comando que utilizaría desde un terminal normal (por ejemplo, el comando ssh), desde una ventana Term.

Un programa que le pida una contraseña normalmente suprimirá el eco de la contraseña, por lo que la contraseña no aparecerá en el búfer. Esto ocurrirá como si estuviera usando un terminal real, si el búfer está en modo char. Si está en modo línea, la contraseña será visible temporalmente, pero se borrará cuando pulse return. (Esto ocurre automáticamente; no hay ningún procesamiento especial de la contraseña).

Cuando se conecta a una máquina diferente, necesita especificar el tipo de terminal que está utilizando, estableciendo la variable de entorno TERM en el entorno para el comando de conexión remota. (Si usa bash, hágalo escribiendo la asignación de la variable antes del comando de inicio de sesión remoto, sin una coma de separación). Los tipos de terminal “ansi” o “vt100” funcionarán en la mayoría de los sistemas.

39.11 Terminal en Serie

Si tiene un dispositivo conectado a un puerto serie de su ordenador, puede comunicarse con él escribiendo M-x serial-term. Este comando pregunta por el nombre y la velocidad del puerto serie, y cambia a un nuevo búfer en modo Term. Emacs se comunica con el dispositivo serie a través de este búfer como lo hace con un terminal en modo Term ordinario.

La velocidad del puerto serie se mide en bits por segundo. La velocidad más común es 9600 bits por segundo. Puede cambiar la velocidad interactivamente haciendo clic en la línea de modo.

Un puerto serie puede configurarse aún más haciendo clic en “8N1” en la línea de modo. Por defecto, un puerto serie está configurado como “8N1”, lo que significa que cada byte consta de 8 bits de datos, Ningún bit de comprobación de paridad y 1 bit de parada.

Si la velocidad o la configuración son incorrectas, no podrá comunicarse con su dispositivo y probablemente sólo verá salida basura en la ventana.

Anterior Siguiente

Compilado con Sphinx usando un tema proporcionado por Read the Docs.

</html>

57 KiB Raw Blame History Unescape Escape