.. _27: ========================= 27 Edición de Programas ========================= Este capítulo describe las características de Emacs para facilitar la edición de programas. Algunas de las cosas que estas características pueden hacer son: * Búsqueda o desplazamiento sobre definiciones de nivel superior (véase :ref:`27.2`). * Aplicación de las convenciones de sangría habituales del lenguaje (véase :ref:`27.3`). * Equilibrar paréntesis (ver :ref:`27.4`). * Insertar, eliminar o alinear comentarios (véase :ref:`27.5`). * Resaltar la sintaxis del programa (véase :ref:`15.3`). 27.1 Modos Principales para Lenguajes de Programación ===================================================== Emacs tiene modos principales especializados (ver :ref:`24.1`) para muchos lenguajes de programación. Un modo de lenguaje de programación normalmente especifica la sintaxis de las expresiones, las reglas habituales de sangría, cómo resaltar la sintaxis del lenguaje y cómo encontrar el principio o el final de la definición de una función. También suele incluir funciones para compilar y depurar programas. El modo principal para cada lenguaje se llama como el lenguaje; por ejemplo, el modo principal para el lenguaje de programación C es ``c-mode``. Emacs tiene modos de lenguaje de programación para Lisp, Scheme, el lenguaje de expresión DSSSL basado en Scheme, Ada, ASM, AWK, C, C++, C#, Fortran, Icon, IDL (CORBA), IDLWAVE, Java, Javascript, M4, Makefiles, Metafont (compañero de TeX para la creación de fuentes), Modula2, Object Pascal, Objective-C, Octave, Pascal, Perl, Pike, PostScript, Prolog, Python, Ruby, Simula, SQL, Tcl, TypeScript, Verilog y VHDL. Un modo alternativo para Perl se denomina modo CPerl. También hay modos disponibles para los lenguajes de scripting de los shells comunes de GNU y Unix, y archivos 'BAT' de MS-DOS/MS-Windows, JSON, archivos maestros DNS, CSS (Cascading Style Sheets), Dockerfiles, archivos CMake, y varios tipos de archivos de configuración. Idealmente, Emacs debería tener un modo principal para cada lenguaje de programación que quiera editar. Si no tiene un modo para su lenguaje favorito, dicho modo puede estar implementado en un paquete no distribuido con Emacs (ver :ref:`49`); o puede contribuir con uno. Si Emacs ha sido compilado con la librería ``tree-sitter``, ofrece varios modos de edición opcionales basados en esa librería, que utilizan las capacidades de análisis incremental proporcionadas por ``tree-sitter``. Estos modos tienen ``-ts-`` en sus nombres; por ejemplo ``c-ts-mode``, ``python-ts-mode``, etc. En la mayoría de los lenguajes de programación, la sangría debe variar de una línea a otra para ilustrar la estructura del programa. Por lo tanto, en la mayoría de los lenguajes de programación, teclear :kbd:`TAB` (``TAB``) actualiza la sangría de la línea actual (ver :ref:`27.3`). Además, ``DEL`` suele estar vinculado a ``backward-delete-char-untabify``, que borra hacia atrás tratando cada tabulación como si fuera el número equivalente de espacios, de modo que puede borrar una columna de sangría sin preocuparse de si el espacio en blanco está formado por espacios o tabulaciones. Al entrar en un modo de lenguaje de programación se ejecutan las funciones personalizadas de Lisp especificadas en la variable de gancho ``prog-mode-hook``, seguidas de las especificadas en el propio *gancho de modo* del propio modo (véase :ref:`24.1`). Por ejemplo, al entrar en modo C se ejecutan los ganchos ``prog-mode-hook`` y ``c-mode-hook``. Ver :ref:`50.2.2`, para información sobre éstos. Hay manuales separados disponibles para los modos para Ada (ver `Modo Ada `_), C/C++/Objective C/Java/Corba IDL/Pike/AWK (ver CC Mode en CC Mode), Octave, VHDL, e IDLWAVE (ver **IDLWAVE** en en el Manual de IDLWAVE). .. _27.2: 27.2 Definiciones de Nivel Superior, o Defuns ============================================= En Emacs, una definición mayor en el nivel superior del búfer, como una función, se llama *defun*. El nombre viene de Lisp, pero en Emacs lo usamos para todos los lenguajes. .. _27.2.1: 27.2.1 Convención del Margen Izquierdo -------------------------------------- Muchos modos de lenguaje de programación han asumido tradicionalmente que cualquier paréntesis de apertura o llave que se encuentre en el margen izquierdo es el comienzo de una definición de nivel superior, o defun. Así, por defecto, los comandos que buscan el comienzo de un defun aceptan tal delimitador como significando esa posición. Si desea anular esta convención, puede hacerlo estableciendo la opción de Usuario ``open-paren-in-column-0-is-defun-start`` a ``nil``. Si esta opción es ``t`` (*true*, verdadero, por defecto), los comandos que buscan el inicio de un defun se detendrán al abrir paréntesis o llaves en la columna cero que no estén en un comentario o cadena. Cuando es ``nil``, los defuns se encuentran buscando paréntesis o llaves en el nivel más externo. Dado que las rutinas Emacs de bajo nivel ya no dependen de esta convención, normalmente no necesitará cambiar ``open-paren-in-column-0-is-defun-start`` de su valor por defecto. .. _27.2.2: 27.2.2 Desplazamiento por defuns -------------------------------- Estos comandos mueven el punto o configuran la región basándose en definiciones principales de nivel superior, también llamadas *defuns*. :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`a` (``C-M-a``) Se mueve al principio del defun actual o precedente (``beginning-of-defun``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`e` (``C-M-e``) Se mueve al final del defun actual o siguiente (``end-of-defun``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`h` (``C-M-h``) Coloca una región alrededor de todo el defun actual o del siguiente (``mark-defun``). Los comandos para desplazarse al principio y al final de la definición actual son ``C-M-a`` (``beginning of defun``, inicio de la definición) y ``C-M-e`` (``end of defun``, final de la definición). Si repite uno de estos comandos, o usa un argumento numérico positivo, cada repetición se mueve al siguiente defun en la dirección del movimiento. ``C-M-a`` con un argumento negativo *-n* avanza n veces hasta el siguiente comienzo de una defun. Este no es exactamente el mismo lugar al que se movería ``C-M-e`` con argumento *n*; el final de este defun no suele ser exactamente el mismo lugar que el principio del siguiente defun. (Espacios en blanco, comentarios, y quizás declaraciones pueden separarlos.) Igualmente, ``C-M-e`` con un argumento negativo se mueve hacia atrás al final de un defun, que no es exactamente el mismo que ``C-M-a`` con un argumento positivo. Para operar sobre el defun actual, use ``C-M-h`` (``mark-defun``), que coloca la marca al final del defun actual y pone el punto en el principio. Véase :ref:`12.2`. Esta es la forma más fácil de prepararse para matar el defun con el fin de moverlo a un lugar diferente en el archivo. Si el defun está directamente precedido por comentarios (sin líneas en blanco intermedias), también se marcan. Si usa el comando mientras el punto está entre defuns, éste usa el defun siguiente. Si usa el comando mientras la marca ya está activa, extiende el final de la región para incluir un defun más. Con un argumento prefijo, marca tantos defuns o extiende la región el número de defuns apropiado. Con un argumento prefijo negativo, marca defuns en la dirección opuesta y también cambia la dirección de selección para usos posteriores de mark-defun. En el modo C, ``C-M-h`` ejecuta la función ``c-mark-function``, que es casi lo mismo que ``mark-defun``; la diferencia es que retrocede sobre las declaraciones de argumentos, el nombre de la función y el tipo de datos devuelto para que toda la función C esté dentro de la región. Este es un ejemplo de cómo los modos principales ajustan las combinaciones de teclas estándar para que realicen sus funciones estándar de una forma que se adapte mejor a un lenguaje en particular. Otros modos principales pueden reemplazar alguna o todas estas combinaciones de teclas para ese propósito. Algunos lenguajes de programación admiten *defuns anidados*, por lo que un defun (como una función o un método o una clase) puede definirse dentro (es decir, como parte del cuerpo) de otro defun. Los comandos descritos anteriormente encuentran por defecto el principio y el final del defun *más interno* alrededor del punto. Los modos principales basados en la librería tree-sitter proporcionan control de este comportamiento: si la variable ``treesit-defun-tactic`` se establece al valor ``top-level``, los comandos defun encontrarán los defuns *más externos* en su lugar. .. _27.2.3: 27.2.3 Imenu ------------ La función Imenu permite encontrar las definiciones principales de un archivo por su nombre. También es útil en los modos principales del formateador de texto, donde trata cada capítulo, sección, etc., como una definición. (Véase :ref:`29.4`, para una función más potente que trata varios archivos juntos). Si teclea :kbd:`Alt`-:kbd:`g` :kbd:`i` (``M-g i``, ``imenu``), lee el nombre de una definición usando el minibúfer, luego mueve el punto a esa definición. Puede usar completar para especificar el nombre; el comando siempre muestra la lista completa de nombres válidos. Alternativamente, puede vincular el comando ``imenu`` a un clic del ratón. Por lo que se muestran los menús del ratón para que seleccione un nombre de definición. También puede añadir el índice del búfer a la barra de menús llamando a ``imenu-add-menubar-index``. Si quiere que este elemento de la barra de menús esté disponible para todos los búferes en un determinado modo principal, puede hacerlo añadiendo ``imenu-add-menubar-index`` a su gancho de modo. Pero si ha hecho eso, tendrá que esperar un poco cada vez que visite un archivo en ese modo, mientras Emacs encuentra todas las definiciones en ese búfer. Cuando cambia el contenido de un búfer, si añade o borra definiciones, puede actualizar el índice del búfer basándose en el nuevo contenido invocando el elemento ``*Rescan*`` del menú. La reexploración se realiza automáticamente si el valor de ``imenu-auto-rescan`` es distinto de cero. No es necesario volver a escanear por pequeños cambios en el texto. ``imenu-auto-rescan`` se desactivará en búferes mayores que ``imenu-auto-rescan-maxout`` en bytes, y la exploración se detendrá si tarda más de ``imenu-max-index-time segundos``. Puede personalizar la forma en que se ordenan los menús configurando la variable ``imenu-sort-function``. Por defecto, los nombres se ordenan según aparecen en el búfer; si desea una ordenamiento alfabético, use el símbolo ``imenu--sort-by-name`` como valor. También puede definir su propia función de comparación escribiendo código Lisp. Si Eglot está activado para el proyecto del búfer actual (véase :ref:`29.2`) y el modo principal del búfer actual, Eglot proporciona su propia facilidad para producir el índice del búfer basándose en el análisis del código fuente del programa por parte del servidor de lenguaje que gestiona el búfer actual. Ver **Características de Eglot** en Eglot: El cliente LSP de Emacs. Imenu proporciona la información para guiar el modo Which Function (ver :ref:`27.2.4`). El Speedbar también puede usarlo (ver :ref:`22.9`). .. _27.2.4: 27.2.4 Modo Qué función (Which Function Mode) --------------------------------------------- El modo Which Function es un modo menor global (véase :ref:`24.2`) que muestra el nombre de la función actual en la línea de modo, actualizándolo a medida que se desplaza por el búfer. Para activar o desactivar el modo Which Function, use el comando ``M-x which-function-mode``. El modo Qué Función es un modo global menor. Por defecto, tiene efecto en todos los modos mayores que saben cómo soportarlo (es decir, todos los modos mayores que soportan Imenu). Puede restringirlo a una lista específica de modos principales cambiando el valor de la variable ``which-func-modes`` de ``t`` (que significa soportar todos los modos principales disponibles) a una lista de nombres de modos principales. .. _27.3: 27.3 Indentación de Programas ============================= La mejor manera de mantener un programa correctamente indentado es usar el Editor para reindentarlo a medida que lo cambia. Emacs tiene comandos para sangrar una sola línea, un número específico de líneas, o todas las líneas dentro de una sola agrupación parentética. Ver :ref:`25`, para información general sobre la indentación. Esta sección describe las características de sangría específicas de los modos de lenguaje de programación. Emacs también proporciona un Lisp pretty-printer en el paquete ``pp``, que reformatea objetos Lisp con una sangría de aspecto agradable. Vea **pp** en el Manual de Referencia de Emacs Lisp. .. _27.3.1: 27.3.1 Comandos Básicos de Indentación de Programas --------------------------------------------------- :kbd:`TAB` (``TAB``) Ajusta la indentación de la línea actual (``indent-for-tab-command``). :kbd:`RET` (``RET``) Inserta una nueva línea, luego ajusta la sangría de la línea siguiente (``newline``). El comando básico de indentación es ``TAB`` (``indent-for-tab-command``), que se documentó en Indentación. En los modos de lenguaje de programación, `` TAB`` indenta la línea actual, basándose en la indentación y el contenido sintáctico de las líneas precedentes; si la región está activa, ``TAB`` indenta cada línea dentro de la región, no sólo la línea actual. El comando ``RET`` (``newline``), que se documentó en :ref:`8.1`, hace lo mismo que ``C-j`` seguido de ``TAB``: inserta una nueva línea, luego ajusta la sangría de la línea. Al indentar una línea que comienza dentro de una agrupación parentética, el Editor normalmente coloca el comienzo de la línea debajo de la línea precedente dentro del grupo, o debajo del texto después del paréntesis. Si manualmente le da a una de estas líneas una sangría no estándar (por ejemplo, por motivos estéticos), las líneas de abajo la seguirán. Los comandos de sangría para la mayoría de los modos de lenguaje de programación asumen que un paréntesis abierto, un corchete abierto u otro delimitador de apertura en el margen izquierdo es el inicio de una función. Si el código que está editando viola esta suposición, incluso si los delimitadores aparecen en cadenas o comentarios-debe establecer ``open-paren-in-column-0-is-defun-start`` a ``nil`` para que la sangría funcione correctamente. Véase :ref:`27.2.1`. 27.3.2 Indentar Varias Líneas ----------------------------- A veces, puede que quiera indentar varias líneas de código a la vez. Una forma de hacerlo es usar la marca; cuando la marca está activa y la región no está vacía, ``TAB`` indenta cada línea de la región. Alternativamente, el comando ``C-M-\`` (``indent-region``) indenta cada línea en la región, esté o no activa la marca (ver :ref:`25.1`). Además, Emacs proporciona los siguientes comandos para sangrar grandes trozos de código: :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`q` (``C-M-q``) Reindenta todas las líneas dentro de una agrupación de paréntesis. :kbd:`Ctrl`-:kbd:`u` :kbd:`TAB` (``C-u TAB``) Desplaza toda una agrupación parentética rígidamente hacia un lado para que su primera línea tenga la sangría adecuada. :kbd:`Alt`-:kbd:`x` ``indent-mode-rigidly`` (``M-x indent-code-rigidly``) Desplaza todas las líneas de la región rígidamente hacia los lados, pero no altera las líneas que empiezan dentro de comentarios y cadenas. Para volver a sangrar el contenido de una sola agrupación de paréntesis, sitúe el punto antes del comienzo de la agrupación y escriba ``C-M-q``. Esto cambia la sangría relativa dentro de la agrupación, sin afectar a su sangría general (es decir, la sangría de la línea donde comienza la agrupación). La función que ejecuta ``C-M-q`` depende del modo principal; es ``indent-pp-sexp`` en modo Lisp, ``c-indent-exp`` en modo C, etc. Para corregir también la sangría general, escriba ``TAB`` primero. Si le gusta la sangría relativa dentro de una agrupación pero no la sangría de su primera línea, mueva el punto a esa primera línea y escriba :kbd:`Ctrl`-:kbd:`u` :kbd:`TAB` (``C-u TAB``). En Lisp, C y algunos otros modos principales, ``TAB`` con un argumento numérico modifica la sangría de la línea actual de la forma habitual y, a continuación, modifica la sangría en la misma cantidad de todas las líneas de la agrupación parentética a partir de la línea actual. Es inteligente, sin embargo, y no altera las líneas que empiezan dentro de cadenas. Tampoco altera las líneas del preprocesador C cuando se está en modo C, pero sí modifica la sangría de cualquier línea de continuación que pueda estar adjunta a ellas. El comando ``M-x indent-code-rigidly`` desplaza lateralmente todas las líneas de la región, como hace ``indent-rigidly`` (véase :ref:`25.1`). No altera la sangría de las líneas que empiezan dentro de una cadena, a menos que la región también empiece dentro de esa cadena. El argumento prefijo especifica el número de columnas a sangrar. 27.3.3. Personalización de la Indentación Lisp ---------------------------------------------- El patrón de indentación para una expresión Lisp puede depender de la función llamada por la expresión. Para cada función Lisp, puede elegir entre varios patrones predefinidos de sangría, o definir uno arbitrario con un programa Lisp. El patrón estándar de sangrado es el siguiente: la segunda línea de la expresión se sangra bajo el primer argumento, si éste se encuentra en la misma línea que el comienzo de la expresión; en caso contrario, la segunda línea se sangra bajo el nombre de la función. Cada línea siguiente se sangrará bajo la línea anterior cuya profundidad de anidamiento sea la misma. Si la variable ``lisp-indent-offset`` no es nula, anula el patrón de sangría habitual para la segunda línea de una expresión, de modo que dichas líneas siempre tienen una sangría ``lisp-indent-offset`` de más columnas que la lista que las contiene. Ciertas funciones anulan el patrón estándar. Las funciones cuyos nombres empiezan por def tratan las segundas líneas como el inicio de un cuerpo, sangrando la segunda línea ``lisp-body-indent`` columnas adicionales más allá del paréntesis abierto que inicia la expresión. Puede anular el patrón estándar de varias formas para funciones individuales, según la propiedad ``lisp-indent-function`` del nombre de la función. Esto se hace normalmente para definiciones de macros, usando la construcción declare. Véase **Definición de Macros** en el Manual de Referencia de Emacs Lisp. En Emacs Lisp, las listas son normalmente sangradas como si fueran formas de tipo función: :: (setq foo '(bar zot gazonk)) Sin embargo, si se añade un espacio después del paréntesis de apertura, esto le dice a Emacs que es una lista de datos en lugar de un trozo de código, y Emacs lo sangrará así: :: (setq foo '( bar zot gazonk)) .. _27.3.4: 27.3.4 Comandos para la Indentación en C ---------------------------------------- Estas son las funciones especiales para la sangría en modo C y modos relacionados: :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`q` (``C-c C-q``) Reindenta la definición de función de nivel superior actual o la declaración de tipo agregado (``c-indent-defun`` en modo CC, ``c-ts-mode-indent-defun`` en modo ``c-ts`` basado en tree-sitter). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`q` (``C-M-q``) Reindenta cada línea de la expresión equilibrada (véase :ref:`27.4.1`), también conocida como "sexp", que sigue al punto. En modo CC, esto invoca ``c-indent-exp``; en modo ``c-ts`` basado en tree-sitter esto invoca un ``prog-indent-sexp`` más general. Un argumento prefijo inhibe los mensajes de advertencia sobre sintaxis no válida. :kbd:`TAB` (``TAB``) Vuelve a sangrar la línea actual, la región activa o el bloque que comienza en esta línea (``c-indent-line-or-region``). Con el argumento prefijo, reentabla rígidamente la expresión equilibrada que comienza en la línea actual, si la línea actual necesita reentablado. Si ``c-tab-always-indent`` es ``t``, este comando siempre reindentará la línea actual y no hará nada más. Este es el valor por defecto. Si esa variable es ``nil``, este comando vuelve a sangrar la línea actual sólo si el punto está en el margen izquierdo o en la sangría de la línea; de lo contrario, inserta un tabulador (o el número equivalente de espacios, si ``indent-tabs-mode`` es ``nil``). Cualquier otro valor (que no sea ``nil`` o ``t``) significa que siempre se vuelve a sangrar la línea, y también se inserta un tabulador si está dentro de un comentario o una cadena. Para reindentar todo el búfer actual, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`h` :kbd:`Ctrl`-:kbd:`Atl`-:kbd:`\\` (``C-x h C-M-\``). Primero se selecciona todo el búfer como región y luego se reindenta esa región. Para reindentar el bloque actual, use ``C-M-u C-M-q``. Esto se desplaza al principio del bloque y luego lo vuelve a indentar. 27.3.5 Personalizar la Indentación en C --------------------------------------- El modo C y los modos relacionados usan un mecanismo flexible para personalizar la sangría. El modo C indenta una línea fuente en dos pasos: primero clasifica la línea sintácticamente según su contenido y contexto; segundo, determina el desplazamiento de indentación asociado por su estilo seleccionado con la construcción sintáctica y lo añade a la indentación de la sentencia de anclaje. :kbd:`Ctrl`-:kbd:`c` :kbd:`.` (``C-c .`` *estilo* ``RET``) Selecciona un estilo predefinido (``c-set-style`` en modo CC, ``c-ts-mode-set-style`` en ``c-ts-mode`` basado en tree-sitter). Un estilo es una colección designada de personalizaciones que pueden usarse en el modo C y en los modos relacionados. **Estilos** en El Manual del Modo CC, para una descripción completa. Emacs viene con varios estilos predefinidos, incluyendo ``gnu``, ``k&r``, ``bsd``, ``stroustrup``, ``linux``, ``python``, ``java``, ``whitesmith``, ``ellemtel``, y ``awk``. Algunos de estos estilos están pensados principalmente para un lenguaje, pero cualquiera de ellos puede usarse con cualquiera de los lenguajes soportados por estos modos. Para saber qué aspecto tiene un estilo, selecciónelo y vuelva a aplicar la sangría a parte del código, por ejemplo, escribiendo :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`q` (``C-M-q``) al principio de la definición de una función. Para elegir un estilo para el búfer actual, use el comando ``C-c ..`` Especifique un nombre de estilo como argumento (las mayúsculas y minúsculas no son significativas). Este comando sólo afecta al búfer actual, y sólo afecta a futuras invocaciones de los comandos de sangría; no reajusta el código que ya está en el búfer. Para cambiar la sangría de todo el búfer al nuevo estilo, puede escribir ``C-x h C-M-\``. Cuando use el modo CC, también puede establecer la variable ``c-default-style`` para especificar el estilo por defecto para varios modos principales. Su valor debe ser el nombre del estilo (una cadena) o una lista, en la que cada elemento especifica un modo principal y qué estilo de sangría usar para él. Por ejemplo, :: (setq c-default-style '((java-mode . "java") (awk-mode . "awk") (other . "gnu"))) especifica opciones explícitas para los modos Java y AWK, y el estilo ``gnu`` por defecto para los otros modos C-como. (Estos ajustes son en realidad los predeterminados.) Esta variable tiene efecto cuando se selecciona uno de los modos principales similares a C; por lo tanto, si especifica un nuevo estilo predeterminado para el modo Java, puede hacer que tenga efecto en un búfer de modo Java existente escribiendo ``M-x java-mode`` allí. Cuando se usa el modo ``c-ts`` basado en tree-sitter, se puede establecer el estilo de sangría por defecto personalizando la variable ``c-ts-mode-indent-style``. El estilo ``gnu`` especifica el formato recomendado por el Proyecto GNU para C; es el predeterminado, para fomentar el uso de nuestro estilo recomendado. Vea **Conceptos Básicos del Motor de Sangría** en el Manual del Modo CC, y Personalización de la Sangría en el Manual del Modo CC, para más información sobre la personalización de la sangría para C y modos relacionados, incluyendo cómo anular partes de un estilo existente y cómo definir sus propios estilos. Como alternativa a especificar un estilo, puedes decirle a Emacs que adivine un estilo tecleando :kbd:`Alt`-:kbd:`x` :kbd:`c` ``guess`` (``M-x c-guess``) en un búfer de código de ejemplo. Luego puede aplicar el estilo adivinado a otros búferes con ``M-x c-guess-install``. Ver **Adivinar el Estilo** en el Manual del Modo CC, para más detalles. .. _27.4: 27.4 Comandos para la Edición con Paréntesis ============================================ Esta sección describe los comandos y características que aprovechan la estructura de paréntesis en un programa, o le ayudan a mantenerla equilibrada. Cuando se habla de estas facilidades, el término "paréntesis" también incluye llaves, corchetes, o cualquier delimitador que se defina para coincidir en pares. El modo principal controla qué delimitadores son significativos, a través de la tabla de sintaxis (véase **Tablas de Sintaxis** en El Manual de Referencia de Emacs Lisp). En Lisp, sólo cuentan los paréntesis; en C, estos comandos se aplican también a llaves y corchetes. Puede usar ``M-x check-parens`` para encontrar cualquier paréntesis y comillas de cadena no balanceados en el búfer. .. _27.4.1: 27.4.1 Expresiones con Paréntesis Equilibrados ---------------------------------------------- Cada modo de lenguaje de programación tiene su propia definición de una *expresión equilibrada*. Las expresiones balanceadas (o equilibradas) típicamente incluyen símbolos individuales, números y constantes de cadena, así como trozos de código encerrados en un par de delimitadores coincidentes. Los siguientes comandos tratan con expresiones balanceadas (en Emacs, tales expresiones se denominan internamente sexps [14]_). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`f` (``C-M-f``) Avanza sobre una expresión equilibrada (``forward-sexp``). :kbd:`Ctrl`-:kbd:`Alt` :kbd:`b` (``C-M-b``) Se desplaza hacia atrás sobre una expresión equilibrada (``backward-sexp``). :kbd:`Ctrl`-:kbd:`Alt` :kbd:`k` (``C-M-k``) Mata la expresión equilibrada hacia adelante (``kill-sexp``). :kbd:`Ctrl`-:kbd:`Alt` :kbd:`t` (``C-M-t``) Transpone expresiones (``transpose-sexps``). | :kbd:`Ctrl`-:kbd:`Alt` :kbd:`@` (``C-M-@``) | :kbd:`Ctrl`-:kbd:`Alt` :kbd:`SPACE` (``C-M-SPC``) Pone una marca después de la siguiente expresión (``mark-sexp``). Para avanzar sobre una expresión equilibrada, use ``C-M-f`` (``forward-sexp``). Si el primer carácter significativo después del punto es un delimitador de apertura (por ejemplo, ``(``, ``[`` o ``{`` en C), este comando se desplaza más allá del delimitador de cierre correspondiente. Si el carácter comienza un símbolo, una cadena o un número, el comando se desplaza por encima. El comando ``C-M-b`` (``backward-sexp``) se desplaza hacia atrás sobre una expresión equilibrada, como ``C-M-f``, pero en sentido inverso. Si la expresión va precedida de prefijos (comillas simples, comillas inversas y comas, en Lisp), el comando también se desplaza sobre ellos. ``C-M-f`` o ``C-M-b`` con un argumento repite esa operación el número de veces especificado; con un argumento negativo significa moverse en la dirección opuesta. En la mayoría de los modos, estos dos comandos se mueven a través de los comentarios como si fueran espacios en blanco. Tenga en cuenta que sus teclas, ``C-M-f`` y ``C-M-b``, son análogas a ``C-f`` y ``C-b``, que se mueven por caracteres (véase :ref:`8.2`), y a ``M-f`` y ``M-b``, que se mueven por palabras (véase :ref:`26.1`). Para eliminar una expresión equilibrada completa, escriba ``C-M-k`` (``kill-sexp``). Esto mata el texto sobre el que se movería ``C-M-f``. ``C-M-t`` (``transpose-sexps``) cambia las posiciones de la expresión balanceada anterior y la siguiente. Es análogo al comando ``C-t``, que transpone caracteres (véase :ref:`17.2`). Un argumento de ``C-M-t`` sirve como contador de repeticiones, desplazando la expresión anterior sobre las siguientes. Un argumento negativo desplaza la expresión equilibrada anterior hacia atrás a través de las anteriores. Un argumento de cero, en lugar de no hacer nada, transpone las expresiones equilibradas que terminan en o después del punto y la marca. Para operar sobre expresiones equilibradas con un comando que actúe sobre la región, escriba :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`SPACE` (``C-M-SPC``, ``mark-sexp``). Esto establece la marca a la que se movería ``C-M-f``. Mientras la marca está activa, cada llamada sucesiva a este comando extiende la región desplazando la marca una expresión. Los argumentos numéricos positivos o negativos desplazan la marca hacia delante o hacia atrás el número de expresiones especificado. El alias ``C-M-@`` es equivalente a ``C-M-SPC``. Consulte :ref:`12.2`, para obtener más información sobre éste y otros comandos afines. En lenguajes que usan operadores infijos, como C, no es posible reconocer todas las expresiones balanceadas porque puede haber múltiples posibilidades en una posición dada. Por ejemplo, el modo C no trata ``foo + bar`` como una única expresión, aunque sea una expresión C; en su lugar, reconoce ``foo`` como una expresión y ``bar`` como otra, con el ``+`` como signo de puntuación entre ellas. Sin embargo, el modo C reconoce ``(foo + bar)`` como una única expresión, debido a los paréntesis. .. [14] La palabra "sexp" se usa para referirse a una expresión en Lisp. 27.4.2 Moverse en la Estructura de Paréntesis --------------------------------------------- Los siguientes comandos se mueven sobre conjuntos delimitados por paréntesis (o cualquier otra cosa que sirva como delimitador en el lenguaje con el que esté trabajando). Ignoran cadenas y comentarios, incluyendo cualquier paréntesis dentro de ellos, y también ignoran paréntesis que estén entrecomillados con un carácter de escape. Estos comandos están pensados principalmente para editar programas, pero pueden ser útiles para editar cualquier texto que contenga paréntesis. Internamente se denominan "órdenes de lista" porque en Lisp estas agrupaciones son listas. Estos comandos suponen que el punto de partida no está dentro de una cadena o un comentario. Si se invocan desde dentro de una cadena o comentario, los resultados son poco fiables. :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`n` (``C-M-n``) Avanza sobre un grupo parentético (``forward-list``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`p` (``C-M-p``) Se desplaza hacia atrás sobre un grupo parentético (``backward-list``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`u` (``C-M-u``) Se mueve hacia arriba en la estructura de paréntesis (``backward-up-list``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`d` (``C-M-d``) Se mueve hacia abajo en la estructura de paréntesis (``down-list``). Los comandos de lista ``C-M-n`` (``forward-list``) y ``C-M-p`` (``backward-list``) avanzan o retroceden sobre una (o *n*) agrupaciones de paréntesis. ``C-M-n`` y ``C-M-p`` intentan permanecer en el mismo nivel de la estructura de paréntesis. Para *subir* uno (o *n*) niveles, use ``C-M-u`` (``backward-up-list``). ``C-M-u`` retrocede hasta un delimitador de apertura no coincidente. Un argumento positivo sirve como contador de repeticiones; un argumento negativo invierte la dirección del movimiento, de modo que el comando se mueve hacia adelante y hacia arriba uno o más niveles. Para moverse hacia *abajo* en la estructura de paréntesis, use ``C-M-d`` (``down-list``). En modo Lisp, donde ``(`` es el único delimitador de apertura, esto es casi lo mismo que buscar un ``(``. Un argumento especifica el número de niveles a bajar. 27.4.3. Correspondencia de Paréntesis ------------------------------------- Emacs tiene un número de características de *concordancia de paréntesis*, que hacen fácil ver cómo y si los paréntesis (u otros delimitadores) concuerdan. Cada vez que escribe un carácter autoinsertado que es un delimitador de cierre, Emacs indica brevemente la localización del delimitador de apertura que coincide, siempre que esté en la pantalla. Si no lo está, el Editor muestra parte del texto cercano en el área de eco. De cualquier forma, puede saber qué agrupación está cerrando. Si el delimitador de apertura y el delimitador de cierre no coinciden -como en ``[x)``- se muestra un mensaje de advertencia en el área de eco. Tres variables controlan la visualización de los paréntesis coincidentes: * ``blink-matching-paren`` activa o desactiva la función: ``nil`` la desactiva, el valor por defecto para activarla es ``t``. Ajústelo a ``jump`` para que la indicación funcione moviendo momentáneamente el cursor al delimitador de apertura coincidente. Establézcalo en ``jump-offscreen`` para que el cursor salte, incluso si el delimitador de apertura está fuera de la pantalla. * ``blink-matching-delay`` dice cuántos segundos se debe mantener la indicación del delimitador de apertura coincidente. Puede ser un número entero o de coma flotante; el valor por defecto es 1. * ``blink-matching-paren-distance`` especifica cuántos caracteres hay que buscar hacia atrás para encontrar el delimitador de apertura coincidente. Si no se encuentra la coincidencia en esa distancia, Emacs deja de buscar y no muestra nada. El valor por defecto es 102400. El modo Mostrar Paréntesis (Show Paren Mode) es un modo menor que proporciona un tipo de concordancia automática más potente. Siempre que el punto esté antes de un delimitador de apertura o después de un delimitador de cierre, se resaltan el delimitador, su delimitador coincidente y, opcionalmente, el texto entre ellos. Para activar el modo Show Paren de forma global, escriba :kbd:`Alt`-:kbd:`x` ``show-paren-mode`` (``M-x show-paren-mode``). Para activarlo sólo en el búfer actual, escriba :kbd:`Alt`:kbd:`x` ``show-paren-local-mode`` (``M-x show-paren-local-mode``). Por defecto, este modo está activado en todos los búferes destinados a la edición, pero no lo está en los búferes que muestran datos. Esto se controla mediante la opción de usuario ``show-paren-predicate``. Para personalizar el modo, escriba :kbd:`Alt`-:kbd:`x` ``customize-group`` :kbd:`RETURN` ``paren-showing`` (``M-x customize-group RET paren-showing``). Las opciones personalizables que controlan el funcionamiento de este modo incluyen: * ``show-paren-highlight-openparen`` controla si se resalta un paréntesis abierto cuando el punto está justo antes de él, y por lo tanto su posición está marcada por el cursor de todos modos. Por defecto no es nulo (yes). * ``show-paren-style`` controla si se resaltan sólo los dos paréntesis, o también el texto entre ellos. Las opciones válidas aquí son ``parenthesis`` (paréntesis, mostrar el paréntesis coincidente), ``expression`` (expresión, resaltar toda la expresión encerrada por los paréntesis), y ``mixed`` (resaltar el paréntesis coincidente si es visible en la ventana, la expresión en caso contrario). * ``show-paren-when-point-inside-paren``, cuando no es ``nil``, hace que se resalte también cuando el punto está dentro del paréntesis. Por defecto es ``nil``. * ``show-paren-when-point-in-periphery``, cuando no es ``nil``, hace que se resalte también cuando el punto está en un espacio en blanco al principio de una línea y hay un paréntesis en la primera o última posición de la línea que no es un espacio en blanco, o cuando el punto está al final de una línea y hay un paréntesis en la última posición de la línea que no es un espacio en blanco. * ``show-paren-context-when-offscreen``, cuando no es nulo, muestra algún contexto en el área de eco cuando el punto está en un delimitador de cierre y el delimitador de apertura está fuera de la pantalla. El contexto suele ser la línea que contiene el delimitador de apertura, excepto si el delimitador de apertura está en su propia línea, en cuyo caso el contexto incluye la línea anterior que no está en blanco. El modo Par eléctrico (Electric Pair mode), un modo global menor, permite insertar fácilmente delimitadores coincidentes: paréntesis, llaves, corchetes, etc. Siempre que inserte un delimitador de apertura, se insertará automáticamente el delimitador de cierre correspondiente, dejando un punto entre ambos. Por el contrario, cuando se inserta un delimitador de cierre sobre otro ya existente, no se produce ninguna inserción y simplemente se omite esa posición. Si la región está activa (véase :ref:`12`), la inserción de un delimitador opera sobre la región: los caracteres de la región se encierran en un par de delimitadores coincidentes, dejando punto después del delimitador que haya escrito. Estas variables controlan características adicionales del modo Par Eléctrico: * ``electric-pair-preserve-balance``, cuando no es nulo, hace que la lógica de pares por defecto equilibre el número de delimitadores de apertura y cierre. * ``electric-pair-delete-adjacent-pairs``, cuando no es nulo, hace que el espacio entre dos delimitadores adyacentes también elimine automáticamente el delimitador de cierre. * ``electric-pair-open-newline-between-pairs``, cuando no es nulo, hace que al insertar una nueva línea entre dos pares adyacentes también se abra automáticamente una nueva línea adicional después del punto. * ``electric-pair-skip-whitespace``, cuando no es ``nil``, hace que el modo menor se salte los espacios en blanco hacia delante antes de decidir si se salta el delimitador de cierre. Para activar el modo Par Eléctrico, escriba :kbd:`Alt`-:kbd:`x` ``electric-pair-mode`` (``M-x electric-pair-mode``). Para activar el modo en un único búfer, use ``M-x electric-pair-local-mode``. .. _27.5: 27.5. Manipulación de Comentarios ================================= Debido a que los comentarios son una parte tan importante de la programación, Emacs proporciona comandos especiales para editarlos e insertarlos. También puede revisar la ortografía de los comentarios con el modo Flyspell Prog (ver :ref:`17.4`). Algunos modos principales tienen reglas especiales para sangrar diferentes tipos de comentarios. Por ejemplo, en el código Lisp, los comentarios que empiezan con dos puntos y coma (``;;``) tienen sangría como si fueran líneas de código, mientras que los que empiezan con tres puntos y coma (``;;;``) se supone que están alineados con el margen izquierdo y se usan a menudo para seccionar. Emacs entiende estas convenciones; por ejemplo, si se escribe :kbd:`TAB` (``TAB``) en una línea de comentario, el comentario se sangrará a la posición adecuada. :: ;; Esta función es sólo un ejemplo. ;;; Aquí dos o tres puntos y coma son apropiados. (defun foo (x) ;;; Y ahora, la primera parte de la función: ;; La siguiente línea añade uno. (1+ x)) ; Esta línea añade uno. .. _27.5.1: 27.5.1 Comandos de Comentario ----------------------------- Los siguientes comandos actúan sobre los comentarios: :kbd:`Alt`-:kbd:`;` (``M-;``) Inserta o realinea el comentario en la línea actual; si la región está activa, comenta o descomenta la región en su lugar (``comment-dwim``). :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`;` (``C-x C-;``) Comenta o descomenta la línea actual (``comment-line``). Si la región está activa, comenta o descomenta las líneas de la región. :kbd:`Ctrl`-:kbd:`u` :kbd:`Alt`-:kbd:`;` (``C-u M-;``) Elimina el comentario de la línea actual (``comment-kill``). :kbd:`Ctrl`-:kbd:`x` :kbd:`;` (``C-x ;``) Establece la columna de comentarios (``comment-set-column``). | :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`j` (``C-M-j``) | :kbd:`Alt`-:kbd:`j` (``M-j``) Como ``RET`` seguido de la inserción y alineación de un comentario (``default-indent-new-line``). Véase :ref:`27.5.2`. | :kbd:`Alt`-:kbd:`x` ``comment-region`` (``M-x comment-region``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`c` (``C-c C-c``)(in C-like modes) Añade delimitadores de comentario a todas las líneas de la región. El comando para crear o alinear un comentario es ``M-;`` (``comment-dwim``). La palabra "dwim" es un acrónimo de "Do What I Mean" (haga lo que quiero decir); indica que este comando puede usar para muchas tareas diferentes relacionadas con los comentarios, dependiendo de la situación en la que lo use. Cuando una región está activa (véase :ref:`12`), ``M-;`` o bien añade delimitadores de comentario a la región, o bien los elimina. Si cada línea de la región ya es un comentario, descomenta cada una de esas líneas eliminando sus delimitadores de comentario. En caso contrario, añade delimitadores de comentario para encerrar el texto de la región. Si proporciona un argumento de prefijo a ``M-;`` cuando una región está activa, éste especifica el número de delimitadores de comentario que se añadirán o eliminarán. Un argumento positivo *n* añade *n* delimitadores, mientras que un argumento negativo *-n* elimina *n* delimitadores. Si la región no está activa y no hay ningún comentario en la línea actual, ``M-;`` añade un nuevo comentario a la línea actual. Si la línea está en blanco (es decir, vacía o contiene sólo caracteres de espacio en blanco), el comentario se sangrará a la misma posición a la que ``TAB`` sangraría (ver :ref:`27.3.1`). Si la línea no está en blanco, el comentario se coloca después del último carácter de la línea que no contenga espacios en blanco. Emacs intenta colocar el comentario entre las columnas especificadas por las variables ``comment-column`` y ``comment-fill-column`` (ver :ref:`27.5.3`), si es posible. Si no, elegirá alguna otra posición adecuada, normalmente separada del texto que no es comentario por al menos un espacio. En cada caso, Emacs coloca el punto después del delimitador inicial del comentario, para que pueda empezar a escribir el texto del comentario inmediatamente. También puede usar ``M-;`` para alinear un comentario existente. Si una línea ya contiene la cadena de inicio de comentario, ``M-;`` la realinea a la alineación convencional y mueve el punto después del delimitador de inicio de comentario. Como excepción, los comentarios que comienzan en la columna 0 no se desplazan. Incluso cuando un comentario existente está correctamente alineado, ``M-;`` sigue siendo útil para desplazarse directamente al inicio del texto del comentario. ``C-x C-;`` (``comment-line) comenta`` o descomenta líneas completas. Cuando una región está activa (véase :ref:`12`), ``C-x C-;`` comenta o descomenta las líneas de la región. Si la región no está activa, este comando comenta o descomenta el punto de línea en el que se encuentra. Con un argumento prefijo positivo *n*, actúa sobre *n* líneas empezando por la actual; con un argumento negativo *-n*, afecta a *n* líneas precedentes. Después de invocar este comando con un argumento negativo, las sucesivas invocaciones con un argumento positivo operarán sobre las líneas precedentes como si el argumento estuviera negado. ``C-u M-;`` (``comment-dwim`` con un argumento prefijo) cuando la región no está activa mata cualquier comentario en la línea actual, junto con el espacio en blanco que lo precede. Dado que el comentario se guarda en el anillo de eliminación, puede volver a insertarlo en otra línea desplazándose hasta el final de esa línea, haciendo ``C-y y``, a continuación, ``M-;`` para realinear el comentario. Puede conseguir el mismo efecto que ``C-u M-;`` escribiendo :kbd:`Alt`-:kbd:`x` ``comment-kill`` (``M-x comment-kill``) (``comment-dwim`` en realidad llama a ``comment-kill`` como subrutina cuando se le da un argumento prefijo). Si se invoca a ``comment-dwim`` con un argumento numérico de prefijo, como en ``C-u n M-;``, cuando no hay ninguna región activa, se le dice a ``comment-kill`` que elimine los comentarios de *n* líneas. El comando ``M-x comment-region`` es equivalente a llamar a ``M-;`` sobre una región activa, salvo que siempre actúa sobre la región, aunque la marca esté inactiva. En modo C y modos relacionados, este comando está ligado a ``C-c C-c``. El comando ``M-x uncomment-region`` descomenta cada línea en la región; un argumento prefijo numérico especifica el número de delimitadores de comentario a eliminar (argumentos negativos especifican el número de delimitadores de comentario a añadir). Para modos similares a C, puede configurar el efecto exacto de ``M-;`` estableciendo las variables ``c-indent-comment-alist`` y ``c-indent-comments-syntactically-p``. Por ejemplo, en una línea que termina en una llave de cierre, ``M-;`` pone el comentario un espacio después de la llave en lugar de en la ``comment-colums``. Para más detalles, consulte **Comandos de Comentario** en el Manual del Modo CC. .. _27.5.2: 27.5.2 Varias Líneas de Comentarios ----------------------------------- Si está escribiendo un comentario y desea continuarlo en otra línea, escriba: :kbd:`Alt`-:kbd:`j` (``M-j``) o (``C-M-j``, ``default-indent-new-line``). Esto rompe la línea actual e inserta los delimitadores de comentario y la sangría necesarios para continuar el comentario. Para lenguajes con delimitadores de comentario de cierre (por ejemplo, ``*/`` en C), el comportamiento exacto de ``M-j`` depende del valor de la variable ``comment-multi-line``. Si el valor es ``nulo``, el comando cierra el comentario en la línea anterior e inicia un nuevo comentario en la nueva línea. En caso contrario, abre una nueva línea dentro de los delimitadores de comentario actuales. Cuando el modo Relleno automático (Auto Fill mode) está activado, pasar la columna de relleno mientras se escribe un comentario también continúa el comentario, del mismo modo que una invocación explícita de ``M-j``. Para convertir líneas existentes en líneas de comentario, use ``M-;`` con la región activa, o use ``M-x comment-region`` como se describe en la sección anterior. Puede configurar el modo C para que cuando escriba una ``/`` al principio de una línea en un comentario de bloque multilínea, se cierre el comentario. Para ello, active la función de limpieza ``comment-close-slash``. Vea **Limpiezas** en el Manual del Modo CC. .. _27.5.3: 27.5.3 Opciones que Controlan los Comentarios --------------------------------------------- Como se mencionó en :ref:`27.5.1`, cuando el comando ``M-j`` añade un comentario a una línea, intenta colocar el comentario entre las columnas especificadas por las variables locales del búfer ``comment-column`` (columna-comentario) y ``comment-fill-column`` (o si es ``nil``, entonces el valor de ``fill-column``, ver :ref:`26.6.2`). Puede establecer el valor local o el valor por defecto de estas variables locales del búfer de la forma habitual (consulte :ref:`50.2.3`). Alternativamente, puede teclear :kbd:`Ctrl`-:kbd:`x` :kbd:`;` (``comment-set-column``) para establecer el valor de ``comment-column`` en el búfer actual a la columna donde se encuentra actualmente el punto. ``C-u C-x ;`` establece la columna de comentario para que coincida con el último comentario antes del punto en el búfer, y luego hace un ``M-;`` para alinear el comentario de la línea actual bajo el anterior. Los comandos de comentario reconocen los comentarios basándose en la expresión regular que es el valor de la variable ``comment-start-skip``. Asegúrese de que esta expresión regular no coincide con la cadena nula. Puede coincidir con más que el delimitador de inicio de comentario en el sentido más estricto de la palabra; por ejemplo, en modo C el valor de la variable podría ser ``/\\*+[ \t]*\|//+[ \t]*``, que coincide con asteriscos y espacios extra después del propio ``/\*``, y acepta también comentarios estilo C++ (``//``). (Observe que ``\\`` es necesario en la sintaxis Lisp para incluir un ``\`` en la cadena, que es necesario para negar a la primera estrella su significado especial en la sintaxis expreg. Véase :ref:`16.7`). Cuando un comando comment crea un nuevo comentario, inserta el valor de ``comment-start`` como delimitador de apertura del comentario. También inserta el valor de ``comment-end`` después del punto, como delimitador de cierre del comentario. Por ejemplo, en modo Lisp, ``comment-start`` es ``";"`` y ``comment-end`` es ``""`` (la cadena vacía). En modo C, ``comment-start`` es ``"/* "`` y ``comment-end`` es ``" */"``. La variable ``comment-padding`` especifica una cadena que los comandos de comentario deben insertar entre el delimitador o delimitadores del comentario y el texto del comentario. El valor por defecto, ``" "``, especifica un único espacio. Alternativamente, el valor puede ser un número, que especifica ese número de espacios, o ``nil``, que significa ningún espacio. La variable ``comment-multi-line`` controla cómo ``M-j`` y el modo Auto Fill continúan los comentarios en múltiples líneas. Véase :ref:`27.5.2`. La variable ``comment-indent-function`` debe contener una función que será llamada para calcular la alineación de un comentario recién insertado o para alinear un comentario existente. Se establece de forma diferente en los distintos modos principales. La función se llama sin argumentos, pero con un punto al principio del comentario, o al final de una línea si se va a insertar un nuevo comentario. Debe devolver la columna en la que debe comenzar el comentario. Por ejemplo, la función por defecto basa su decisión en cuántos caracteres de comentario comienzan un comentario existente. Emacs también intenta alinear los comentarios en líneas adyacentes. Para anular esto, la función puede devolver una cons de dos enteros (posiblemente iguales) para indicar un rango aceptable de sangría. .. _27.6: 27.6 Búsqueda de Documentación ============================== Emacs proporciona varias características que puede usar para buscar la documentación de funciones, variables y comandos que planea usar en su programa. 27.6.1 Búsqueda de Documentación en Info ---------------------------------------- Para los modos principales que se aplican a lenguajes que tienen documentación en Info, puede usar ``C-h S`` (``info-lookup-symbol``) para ver la documentación Info de un símbolo usado en el programa. Especifique el símbolo con el minibúfer; el valor predeterminado es el símbolo que aparece en el búfer en el punto. Por ejemplo, en modo C se busca el símbolo en el Manual de la Biblioteca C. El comando sólo funciona si están instalados los archivos Info del manual correspondiente. Emacs determina dónde buscar la documentación para el símbolo, en qué archivos Info y en qué índices buscar, basándose en el modo principal. También puede usar ``M-x info-lookup-file`` para buscar documentación para un nombre de archivo. Si usa ``C-h S`` en un modo principal que no lo soporta, le pedirá que especifique el modo de ayuda del símbolo. Debe introducir un comando como ``c-mode`` que seleccionaría un modo principal que ``C-h S`` sí soporta. 27.6.2. Búsqueda en la Página man --------------------------------- En Unix, la principal forma de documentación en línea era la *página de manual* o *página man*. En el sistema operativo GNU, nuestro objetivo es reemplazar las páginas man por manuales mejor organizados que pueda consultar con Info (vea :ref:`11.8`). Este proceso no está terminado, por lo que todavía es útil leer las páginas de manual. Puede leer la página man de un comando del sistema operativo, función de biblioteca o llamada al sistema, con el comando ``M-x man``. Esto solicita un tema, con completado (ver :ref:`9.4`), y ejecuta el programa ``man`` para formatear la página man correspondiente. Si el sistema lo permite, ejecuta man de forma asíncrona, para que pueda seguir editando mientras se formatea la página. El resultado va a un búfer llamado ``*Man topic*``. Estos búferes usan un modo principal especial, el modo Man, que facilita el desplazamiento y el salto a otras páginas de manual. Para más detalles, teclee :kbd:`Ctrl`-:kbd:`h` :kbd:`m` (``C-h m``) mientras se encuentre en un búfer en modo Man (man Mode). Cada página del manual pertenece a una de las diez o más *secciones*, cada una de ellas nombrada por un dígito o por un dígito y una letra. A veces hay páginas del manual con el mismo nombre en diferentes secciones. Para leer una página del manual de una sección específica, escriba ``topic(section)`` o ``section topic`` cuando ``M-x man`` le pregunte por el tema. Por ejemplo, la página del manual de la función ``chmod`` de la biblioteca C está en la sección 2, pero hay un comando de shell con el mismo nombre, cuya página del manual está en la sección 1; para ver la primera, escriba :kbd:`Alt`-:kbd:`x` ``man(2)`` :kbd:`RETURN` ``chmod`` :kbd:`RETURN` (``M-x man RET chmod(2) RET``). Si no especifica una sección, ``M-x man`` normalmente muestra sólo la primera página man encontrada. En algunos sistemas, el programa man acepta una opción de línea de comandos ``-a``, que le indica que muestre todas las páginas man del tema especificado. Para usar esta opción, cambie el valor de la variable ``Man-switches`` a ``"-a"``. Entonces, en el búfer del modo Man, puede escribir :kbd:`Alt`-:kbd:`n` (``M-n``) y :kbd:`Alt`-:kbd:`p` (``M-p``) para cambiar entre páginas de manual de diferentes secciones. La línea de modo muestra cuántas páginas de manual hay disponibles. Una forma alternativa de leer páginas de manual es el comando ``M-x woman``. A diferencia de ``M-x man``, no ejecuta ningún programa externo para formatear y mostrar las páginas de manual; el formateo lo hace Emacs, por lo que funciona en sistemas como MS-Windows donde el programa man puede no estar disponible. Pide una página man, y la muestra en un búfer llamado ``*WoMan section topic``. ``M-x woman`` calcula la lista de completado de las páginas de manual la primera vez que se invoca el comando. Con un argumento numérico, vuelve a calcular esta lista; esto es útil si añade o elimina páginas de manual. Si escribe el nombre de una página de manual y ``M-x woman`` encuentra que existen varias páginas de manual con el mismo nombre en diferentes secciones, aparece una ventana con posibles candidatos pidiéndole que elija uno de ellos. Tenga en cuenta que ``M-x woman`` aún no soporta las últimas características de las páginas man modernas, por lo que recomendamos usar ``M-x man`` si está disponible en su sistema. Para más información sobre cómo configurar y usar ``M-x woman``, vea el manual **WoMan Info**, que se distribuye con Emacs. .. _27.6.3: 27.6.3. Búsqueda de Documentación en Lenguajes de Programación -------------------------------------------------------------- Cuando edite código Emacs Lisp, puede usar los comandos ``C-h f`` (``describe-function``) y ``C-h v`` (``describe-variable``) para ver la documentación incorporada para las funciones y variables Lisp que quiera usar. Consulte :ref:`11.3`. ElDoc [15]_ es un modo menor de búfer local que ayuda a buscar documentación de símbolos (funciones, métodos, clases, variables, etc.) en su programa. Cuando este modo está activado, el área de eco muestra información útil siempre que haya un símbolo documentado en el punto. Por ejemplo, en búferes bajo el modo Emacs Lisp, muestra la lista de argumentos de una función en el punto, y para una variable Lisp muestra la primera línea de la cadena de documentación de la variable. Para activar el modo ElDoc, escriba :kbd:`Alt`-:kbd:`x` ``eldoc-mode`` (``M-x eldoc-mode``)`. También existe un modo ElDoc global, que está activado por defecto, y activa el modo ElDoc en los búferes cuyo modo principal establece las variables que se describen a continuación. Use ``M-x global-eldoc-mode`` para desactivarlo globalmente. Varios modos principales configuran el modo ElDoc global para usar sus funciones de documentación. Algunos ejemplos son el modo Emacs Lisp, el modo Python y el modo Cfengine. Además, las características de Emacs que proporcionan soporte para varios modos principales configuran ElDoc para usar sus facilidades para recuperar la documentación. Algunos ejemplos son Eglot (ver **Características de Eglot** en Eglot: El cliente LSP de Emacs), que proporciona documentación basada en la información de los servidores de lenguajes; el modo Resumen inactivo de Semantic (ver **Modo Resumen** Inactivo en el Manual de Semantic); y Flymake, que usa ElDoc para mostrar diagnósticos en el punto (ver **Encontrando Diagnósticos** en el manual GNU Flymake). El modo ElDoc funciona programando la visualización de la documentación disponible para el símbolo en el punto después de que Emacs haya estado inactivo durante un breve periodo de tiempo. Esto evita el molesto parpadeo de los mensajes de documentación en el área de eco o en la línea de modo cuando se escribe rápidamente y sin demora. También puede activar la visualización de la documentación de un símbolo en un punto usando el comando ``M-x eldoc-print-current-symbol-info``. Se pueden usar las siguientes variables para configurar el modo ElDoc: ``eldoc-idle-delay`` El valor de esta opción de Usuario controla el tiempo de espera antes de que se muestre la documentación del punto de acceso. Debe establecerse en el número de segundos a esperar; el valor de cero significa mostrar sin ningún retraso. El valor por defecto es 0,5 seg. ``eldoc-print-after-edit`` Si esta opción de Usuario no es nula, ElDoc mostrará la documentación sólo después de algún comando de edición, como insertar o borrar algún texto. Esto es útil si quiere que Emacs muestre la documentación sólo sobre los símbolos que escriba, pero no sobre los símbolos que ya están en el búfer (por lo que la simple lectura del código fuente no mostrará la documentación). El valor por defecto es ``nil``. Si cambia el valor, necesita activar y desactivar ``eldoc-mode``. ``eldoc-echo-area-use-multiline-p`` Esta opción de Usuario controla si y cómo truncar el texto de la documentación si es más largo de lo que el área de eco puede mostrar como una sola línea de pantalla. Si el valor es un número positivo, especifica el número de líneas de pantalla que ElDoc puede mostrar en el área de eco sin truncar la documentación. Un número entero positivo especifica el número máximo absoluto de líneas de pantalla que se pueden usar; un número en coma flotante especifica el número de líneas de pantalla como fracción de la altura del marco. El valor ``t`` significa no truncar nunca la documentación (el área de eco se redimensionará hasta la altura permitida por ``max-mini-window-height``, ver :ref:`9.3`), mientras que el valor ``nil`` significa truncar si la documentación es más larga que una sola línea de pantalla. Por último, el valor especial ``truncate-sym-name-if-fit`` (por defecto) significa truncar la parte de la documentación que representa el nombre de un símbolo si al hacerlo la documentación cabe en una sola línea de pantalla. ``eldoc-echo-area-display-truncation-message`` Si no es ``nil`` (por defecto), y la documentación mostrada en el área de eco está truncada porque es demasiado larga, siga la documentación por instrucciones sobre cómo ver el texto completo de la documentación. Si es ``nil``, simplemente indique con ``...`` que la documentación fue truncada. ``eldoc-echo-area-prefer-doc-buffer`` Si el valor de esta opción de Usuario es ``t``, ElDoc no mostrará la documentación en el área de eco si el búfer de ElDoc con la documentación ya se muestra en alguna ventana. (Puede usar el comando ``M-x eldoc-doc-buffer`` en cualquier momento para mostrar el búfer de ElDoc). Si el valor de esta opción es el símbolo tal vez, la documentación no se mostrará en el área de eco si el búfer ElDoc se muestra en alguna ventana, y el texto de la documentación deberá truncarse si se muestra en el área de eco. Por último, el valor ``nil`` (por defecto) significa mostrar siempre la documentación en el área de eco. ``eldoc-documentation-strategy`` El valor de esta variable personalizable es la función que se usa para recuperar y mostrar la documentación del símbolo en cuestión. La documentación es producida por las funciones del gancho ``eldoc-documentation-functions``. El valor predeterminado de ``eldoc-documentation-strategy`` especifica que ElDoc debe mostrar el primer texto de documentación producido por las funciones de gancho ``eldoc-documentation-functions``, pero puede personalizar ``eldoc-documentation-strategy`` para que funcione de otras formas, como mostrar todos los textos de documentación concatenados. ``eldoc-documentation-functions`` El valor de este gancho anormal es una lista de funciones que pueden producir documentación para el símbolo en el punto apropiado para el modo principal del búfer actual. Estas funciones actúan como una colección de backends para ElDoc. Los modos principales registran sus funciones de búsqueda de documentación con ElDoc añadiendo sus funciones al valor local del búfer de esta variable. .. [15] El nombre "Eldoc" es un accidente histórico: este modo comenzó al soportar los buffers LISP de Emacs. .. _27.7: 27.7 Modo Menor para Ocultamiento (Hideshow) ============================================ El modo Hideshow (modo de Ocultamiento) es un modo menor local del búfer que le permite mostrar selectivamente porciones de un programa, que se denominan *bloques*. Escriba :kbd:`Alt`-:kbd:`x` ``hs-minor-mode`` (``M-x hs-minor-mode``) para activar este modo menor (ver :ref:`24.2`). Cuando usa el modo Hideshow para ocultar un bloque, éste desaparece de la pantalla y es sustituido por una elipsis (tres puntos seguidos). Lo que constituye un bloque depende del modo principal. En el modo C y los modos relacionados, los bloques se delimitan mediante llaves, mientras que en el modo Lisp se delimitan mediante paréntesis. Los comentarios multilínea también cuentan como bloques. El modo Hideshow proporciona los siguientes comandos: | :kbd:`Ctrl`-:kbd:`e` :kbd:`@` :kbd:`Ctrl`-:kbd:`h` (``C-c @ C-h``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`d` (``C-c @ C-d``) Oculta el bloque actual (``hs-hide-block``). :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`s` (``C-c @ C-s``) Muestra el bloque actual (``hs-show-block``). | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`c` (``C-c @ C-c``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`e` (``C-c @ C-e``) | :kbd:`Shift`-``ratón-2`` (``S-ratón-2``) Oculta o muestra el bloque actual (``hs-toggle-hiding``). | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`h` (``C-c @ C-M-h``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`t` (``C-c @ C-t``) Oculta todos los bloques de nivel superior (``hs-hide-all``). | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`s` (``C-c @ C-M-s``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`a` (``C-c @ C-a``) Muestra todos los bloques del búfer (``hs-show-all``). :kbd:`Ctrl`-:kbd:`u` *n* :kbd:`Ctrl`-:kbd:`c` :kbd:`@` :kbd:`Ctrl`-:kbd:`l` (``C-u`` *n* ``C-c @ C-l``) Oculta todos los bloques *n* niveles por debajo de este bloque (``hs-hide-level``). Estas variables se pueden usar para personalizar el modo Hideshow: ``hs-hide-comments-when-hiding-all`` Si no es nulo, ``C-c @ C-M-h`` (``hs-hide-all``) oculta también los comentarios. ``hs-isearch-open`` Esta variable especifica las condiciones en las que la búsqueda incremental debe desocultar un bloque oculto cuando aparece texto coincidente dentro del bloque. Su valor debe ser ``code`` (desoculta sólo bloques de código), ``comment`` (desoculta sólo comentarios), ``t`` (desoculta tanto bloques de código como comentarios) o ``nil`` (desoculta ni bloques de código ni comentarios). El valor por defecto es ``code``. .. _27.8: 27.8 Completado de Nombres de Símbolos ====================================== El completado se hace normalmente en el minibúfer (ver :ref:`9.4`), pero también puede completar nombres de símbolos en búferes Emacs ordinarios. En la mayoría de los modos de lenguaje de programación, ``C-M-i`` (o ``M-TAB`` [16]_) invoca el comando ``completion-at-point``, que genera la lista de posibles terminaciones para el símbolo en el punto. Este comando usa las facilidades de soporte disponibles para obtener las terminaciones candidatas: Si Eglot está activado para el proyecto del búfer actual (véase :ref:`29.2`) y el modo principal del búfer actual, el comando intenta usar el servidor de idiomas correspondiente para producir la lista de candidatos a finalización. Véase **Características de Eglot** en Eglot: El cliente LSP de Emacs. Si el modo Semántico está habilitado (ver :ref:`27.10`), el comando intenta usar los datos del analizador semántico para completar. Si el modo Semántico (Semantic mode) no está habilitado o falla al completar, el comando intenta completar usando la tabla de etiquetas seleccionada (ver :ref:`29.4.2`); necesita visitar la tabla de etiquetas con ``M-x visit-tags-table`` para que funcione. En modo Emacs Lisp, el comando usa los nombres de función, variable o propiedad definidos en la sesión Emacs actual. En todos los demás aspectos, el completado de símbolos en el búfer se comporta como el completado en el minibúfer. Por ejemplo, si Emacs no puede completar un único símbolo, muestra una lista de alternativas de completado en otra ventana. Entonces puede usar las teclas :kbd:`Alt`-:kbd:`↓` (``M-DOWN``) y :kbd:`Alt`-:kbd:`↑` (``M-UP``) para navegar a través de los completados mostrados en el búfer de completados sin dejar el búfer original, y la tecla :kbd:`Alt`-:kbd:`RETURN` (``M-RET``) para insertar el completado actualmente resaltado en el búfer. Véase :ref:`9.4`. En el modo Texto (Text mode) y modos relacionados, ``M-TAB`` completa las palabras basándose en el diccionario del corrector ortográfico. Véase :ref:`17.4`. .. [16] En las pantallas gráficas, la tecla :kbd:`Alt`-:kbd:`TAB` (``M-TAB``) suele estar reservada por el gestor de ventanas para cambiar de ventana gráfica, por lo que deberá teclear :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`i` (``C-M-i``) o :kbd:`ESC`:kbd:`TAB` (``ESC TAB``) en su lugar. .. _27.9: 27.9 Palabras en Mayúsculas y Minúsculas ======================================== Algunos estilos de programación usan símbolos mixtos (o "CamelCase") como ``unReadableSymbol``. (En el proyecto GNU, recomendamos usar guiones bajos para separar palabras dentro de un identificador, en lugar de usar distinciones entre mayúsculas y minúsculas). Emacs tiene varias características para hacer más fácil tratar con tales símbolos. El modo Visor (Glasses mode) es un modo menor localizado en el búfer que facilita la lectura de tales símbolos, alterando la forma en que se muestran. Por defecto, muestra guiones bajos adicionales entre cada letra minúscula y la siguiente mayúscula. Esto no altera el texto del búfer, sólo cómo se muestra. Para activar este modo, escriba :kbd:`Alt`-:kbd:`x` ``glasses-mode`` (``M-x glasses-mode``) (véase :ref:`24.2`). Cuando el modo Visor está activado, aparece el indicador de modo menor ``o^o`` en la línea de modo. Para obtener más información sobre el modo Glasses, escriba :kbd:`Ctrl`-:kbd:`h` :kbd:`P` ``glasses`` :kbd:`RETURN` (``C-h P glasses RET``). El modo Subpalabra (Subword mode) es otro modo menor local del búfer. En modo subpalabra, los comandos de palabra de Emacs reconocen las letras mayúsculas en ``StudlyCapsIdentifiers`` como límites de palabra. Cuando este modo está activado, el indicador de modo menor ``,`` aparece en la línea de modo. Véase también el modo similar superpalabra (``superword-mode``) (véase :ref:`27.11`). .. _27.10: 27.10 Semántica =============== Semantic es un paquete que proporciona comandos de edición conscientes del lenguaje y basados en *analizadores de código fuente* (``source code parser``). Esta sección proporciona una breve descripción de Semantic; para más detalles, véase **Semantic** en la Guía de Semantic. La mayoría de las funciones de Emacs que tienen en cuenta el lenguaje, como el modo de bloqueo de fuentes (véase :ref:`15.3`), se basan en reglas empíricas [17]_ que suelen dar buenos resultados pero que nunca son del todo exactas. En cambio, los analizadores sintácticos que usa Semantic comprenden con exactitud la sintaxis de los lenguajes de programación. Esto permite a Semantic proporcionar comandos de búsqueda, navegación y finalización potentes y precisos. Para empezar a usar Semantic, escriba :kbd:`Alt`-:kbd:`x` ``semantic-mode`` (``M-x semantic-mode``) o haga clic en la opción de menú denominada ``Source Code Parsers (Semantic)`` en el menú ``Tools`` (Herramientas). Esto activa el modo Semántico, un modo global menor. Cuando el modo semántico está activado, Emacs intenta analizar automáticamente cada archivo que visita. Actualmente, Semantic entiende C, C++, HTML, Java, Javascript, Make, Python, Scheme, SRecode y Texinfo. Dentro de cada búfer analizado, están disponibles los siguientes comandos: :kbd:`Ctrl`-:kbd:`c` :kbd:`,`:kbd:`j` (``C-c , j``) Pregunta por el nombre de una función definida en el archivo actual y mueve el punto allí (``semantic-complete-jump-local``). :kbd:`Ctrl`-:kbd:`c` :kbd:`,`:kbd:`J` (``C-c , J``) Pregunta por el nombre de una función definida en cualquier archivo que Emacs haya analizado, y mueve el punto allí (``semantic-complete-jump``). :kbd:`Ctrl`-:kbd:`c` :kbd:`,`:kbd:`SPACE` (``C-c , SPC``) Muestra una lista de posibles terminaciones para el símbolo en cuestión (``semantic-complete-analyze-inline``). Esto también activa un conjunto de combinaciones de teclas especiales para elegir una terminación: ``RET`` acepta la terminación actual, ``M-n`` y ``M-p`` recorren las posibles terminaciones, ``TAB`` completa hasta donde sea posible y luego recorre el ciclo, y ``C-g`` o cualquier otra tecla aborta la terminación. :kbd:`Ctrl`-:kbd:`c` :kbd:`,`:kbd:`l` (``C-c , l``) Muestra una lista de las posibles terminaciones del símbolo en el punto, en otra ventana (``semantic-analyze-possible-completions``). Además de los comandos anteriores, el paquete Semantic proporciona otras formas de usar la información del analizador sintáctico. Por ejemplo, puede usarlo para mostrar una lista de terminaciones cuando Emacs está inactivo. Ver **Semantic** en la Guía de Semantic, para más detalles. .. [17] Expresiones regulares y tablas de sintaxis. .. _27.11: 27.11 Otras Funciones Útiles para Editar Programas ================================================== Algunos comandos de Emacs que no están diseñados específicamente para editar programas son útiles para ello. Los comandos de Emacs que operan sobre palabras, frases y párrafos son útiles para editar código. La mayoría de los nombres de símbolos contienen palabras (ver :ref:`26.1`), mientras que las sentencias se pueden encontrar en cadenas y comentarios (ver :ref:`26.2`). En cuanto a los párrafos, están definidos en la mayoría de los modos del lenguaje de programación para comenzar y terminar en líneas en blanco (véase :ref:`26.3`). Por lo tanto, usar juiciosamente las líneas en blanco para hacer el programa más claro también proporcionará trozos de texto útiles para que trabajen los comandos de párrafo. El modo Relleno Automático (Auto Fill mode), si está activado en un modo principal de lenguaje de programación, aplica sangría a las nuevas líneas que crea. El modo Superpalabra es un modo menor localizado en el búfer que hace que los comandos de edición y movimiento traten los símbolos (por ejemplo, ``esto_es_un_símbolo``) como palabras. Cuando el modo Superpalabra está activado, el indicador de modo menor ``²`` aparece en la línea de modo. Véase también el modo similar de subpalabra (``subword-mode``) (véase :ref:`27.9`). El modo Diseño Eléctrico (Electric Layout) (`M-x electric-layout-mode``) es un modo menor global que inserta automáticamente nuevas líneas cuando se escriben ciertos caracteres; por ejemplo, ``{``, ``}`` y ``;`` en el modo Javascript. Aparte del modo Presentación (mode Hideshow) (ver :ref:`27.7`), otra forma de mostrar selectivamente partes de un programa es usar la función de visualización selectiva (ver :ref:`15.18`). Los modos de programación también suelen soportar el modo menor Esquema (véase :ref:`26.9`), que puede usarse con el paquete Plegado (véase :ref:`26.9.6`). El modo Prettify Symbols es un modo menor localizado en el búfer que sustituye ciertas cadenas por versiones más atractivas para su visualización. Por ejemplo, en el modo Emacs Lisp, sustituye la cadena ``lambda`` por el carácter lambda griego ``λ``. En un búfer TeX, sustituirá ``\alpha`` ... ``\omega`` y otras macros matemáticas por sus caracteres Unicode. Puede usar esto también en modos que no sean de programación. Puede personalizar el modo añadiendo más entradas a ``prettify-symbols-alist``. Una personalización más elaborada está disponible mediante la personalización de ``prettify-symbols-compose-predicate`` si su valor por defecto ``prettify-symbols-default-compose-p`` no es apropiado. También existe una versión global, ``global-prettify-symbols-mode``, que activa el modo en todos los búferes que lo soportan. El símbolo en el punto puede mostrarse en su forma original. Esto se controla mediante la variable ``prettify-symbols-unprettify-at-point``: si no es nula, la forma original del símbolo en el punto se restaurará mientras el punto esté en él. 27.12 C y Modos Relacionados ============================ Esta sección ofrece una breve descripción de las características especiales disponibles en los modos C, C++, Objective-C, Java, CORBA IDL, Pike y AWK. (Se denominan "modo C y modos relacionados".) Para más detalles, consulte el manual de información del modo CC, que se distribuye con Emacs. 27.12.1 Comandos de Movimiento en Modo C ---------------------------------------- Esta sección describe los comandos para mover el punto, en modo C y modos relacionados. | :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`a` (``C-M-a``) | :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`e` (``C-M-e``) Mueve el punto al principio o al final de la función actual o de la definición de nivel superior. En lenguajes con ámbitos delimitadores (como las clases de C++) la *función actual* es la inmediata, posiblemente dentro de un campo específico de una aplicación. En caso contrario, es la definida por las llaves menos cercanas. (Por el contrario, ``beginning-of-defun`` y ``end-of-defun`` buscan llaves en la columna cero). Véase :ref:`27.2.2`. :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`u` (``C-u C-u``) Mueve el punto de nuevo al condicional de preprocesador contenedor, dejando atrás la marca. Un argumento prefijo actúa como un contador de repeticiones. Con un argumento negativo, mueve el punto hacia adelante hasta el final de la condicional del preprocesador que lo contiene. ``#elif`` es equivalente a ``#else`` seguido de ``#if``, por lo que la función se detendrá en un ``#elif`` cuando vaya hacia atrás, pero no cuando vaya hacia delante. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`p` (``C-c C-p``) Mueve el punto hacia atrás sobre una condicional de preprocesador, dejando la marca detrás. Un argumento prefijo actúa como una cuenta de repetición. Con un argumento negativo, avanza. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`n` (``C-c C-n``) Mueve el punto hacia adelante a través de un condicional de preprocesador, dejando la marca detrás. Un argumento prefijo actúa como una cuenta de repetición. Con un argumento negativo, se mueve hacia atrás. :kbd:`Alt`-:kbd:`a` (``M-a``) Mueve el punto al principio de la sentencia C más interna (``c-beginning-of-statement``). Si el punto ya está al principio de una sentencia, se mueve al principio de la sentencia precedente. Con el argumento prefijo *n*, retrocede *n* - 1 sentencias. En comentarios o en cadenas que abarcan más de una línea, este comando se mueve por oraciones en lugar de por sentencias. :kbd:`Atl`-:kbd:`e` (``M-e``) Mueve el punto al final del enunciado o frase C más interior; como ``M-a`` excepto que se mueve en la otra dirección (``c-end-of-statement``). 27.12.2 Caracteres C Eléctricos ------------------------------- En modo C y modos relacionados, ciertos caracteres de impresión son *eléctricos*, además de insertarse a sí mismos, también reindentan la línea actual, y opcionalmente también insertan nuevas líneas. Los caracteres eléctricos son ``{``, ``}``, ``:``, ``#``, ``;``, ``,``, ``<``, ``>``, ``/``, ``*``, ``(``, y ``)``. Puede que la sangría eléctrica le resulte incómoda si está editando código con sangría caótica. Si es nuevo en el modo CC, puede que le resulte desconcertante. Puede activar la acción eléctrica con el comando ``C-c C-l``; cuando está activada, ``/cl`` aparece en la línea de modo después del nombre del modo (donde *c*, si está presente, es ``*`` o ``/``, dependiendo de si el estilo de comentario es bloque o línea). Consulte **Modos Menores** en el Manual del Modo CC, para más información sobre los indicadores de línea de modo en el Modo CC. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`l` (``C-c C-l``) Alterna la acción eléctrica (``c-toggle-electric-state``). Con un argumento prefijo positivo, este comando activa la acción eléctrica, con uno negativo la desactiva. Los caracteres eléctricos insertan nuevas líneas sólo cuando, además del estado eléctrico, está activada la función ``auto-newline`` (indicada por ``/cla`` en la línea de modo después del nombre del modo). Puede activar o desactivar esta función con el comando ``C-c C-a``: :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`a` (``C-c C-a``) Activa la función de ``auto-newline`` (``c-toggle-auto-newline``). Con un argumento prefijo, este comando activa la función de ``auto-newline`` si el argumento es positivo, y la desactiva si es negativo. Normalmente el estilo Modo CC configura las circunstancias exactas en las que Emacs inserta ``auto-newlines``. También puede configurar esto directamente. Vea **Nuevas Líneas Automáticas Personalizadas** en el Manual CC). 27.12.3. Característica de Borrado Forzado en C ----------------------------------------------- Si quiere borrar un bloque entero de espacio en blanco en un punto, puede usar el *borrado a la fueraza* (hungry deletion). Esto borra todo el espacio en blanco contiguo antes o después del punto en una sola operación. Los espacios en blanco incluyen tabuladores y nuevas líneas, pero no comentarios ni comandos del preprocesador. | :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`DEL` (``C-c C-DEL``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`DEL` (``C-c DEL``) Elimina todo el bloque de espacios en blanco que precede al punto (``c-hungry-delete-backwards``). | :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`d` (``C-c C-d``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`Delete` (``C-c C-Delete``) | :kbd:`Ctrl`-:kbd:`c` :kbd:`Delete` (``C-c Delete``) Borra todo el bloque de espacios en blanco después del punto (``c-hungry-delete-forward``). Como alternativa a los comandos anteriores, puede activar el modo de borrado forzoso. Cuando esta función está activada (indicada por ``h`` después de ``/`` en la línea de modo después del nombre del modo), un solo ``DEL`` borra todos los espacios en blanco precedentes, no sólo un espacio, y un solo ``C-d`` (pero no ``Delete`` normal) borra todos los espacios en blanco siguientes. :kbd:`Alt`-:kbd:`x` ``c-toggle-hungry-state`` (``M-x c-toggle-hungry-state``) Activa la función de borrado forzoso (``c-toggle-hungry-state``). Con un argumento prefijo, este comando activa dicha función si el argumento es positivo, y la desactiva si es negativo. La variable ``c-hungry-delete-key`` controla si la función ``hungry-delete`` está activada. .. _27.12.4: 27.12.4 Otros comandos para el Modo C ------------------------------------- :kbd:`Alt`-:kbd:`x` ``c-context-break`` (``M-x c-context-line-break``) Este comando inserta un salto de línea y aplica a la nueva línea la sangría adecuada al contexto. En código normal, hace el trabajo de ``RET`` (``newline``, nueva línea), en una línea de preprocesador C inserta adicionalmente un ``\`` en el salto de línea, y dentro de los comentarios es como ``M-j`` (``c-indent-new-comment-line``). ``c-context-line-break`` no está vinculado a una tecla por defecto, pero necesita una vinculación para ser útil. El siguiente código lo vinculará a ``RET``. Usamos ``c-initialization-hook`` aquí para asegurarnos de que el mapa de teclado está cargado antes de intentar cambiarlo. :: (defun my-bind-clb () (keymap-set c-mode-base-map "RET" 'c-context-line-break)) (add-hook 'c-initialization-hook 'my-bind-clb) :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`h` (``C-M-h``) Pone marca al final de la definición de una función, y pone punto al principio ( ``c-mark-function``). :kbd:`Alt`-:kbd:`q` (``M-q``) Rellena un párrafo, manejando comentarios en C y C++ (``c-fill-paragraph``). Si cualquier parte de la línea actual es un comentario o está dentro de un comentario, este comando rellena el comentario o el párrafo del mismo en el que se encuentra ese punto, preservando la sangría del comentario y los delimitadores del comentario. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`e` (``C-c C-e``) Ejecuta el preprocesador C sobre el texto de la región, y muestra el resultado, que incluye la expansión de todas las llamadas a macros (``c-macro-expand``). El texto del búfer antes de la región también se incluye en el preprocesamiento, por las macros definidas allí, pero la salida de esta parte no se muestra. Cuando está depurando código C que usa macros, a veces es difícil averiguar con precisión cómo se expanden las macros. Con este comando, no tendrá que averiguarlo; podrá ver las expansiones. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`\\` (``C-c C-\``) Inserta o alinea caracteres ``\`` en los extremos de las líneas de la región (``c-backslash-region``). Esto es útil después de escribir o editar una definición de macro C. Si una línea ya termina en ``\``, este comando ajusta la cantidad de espacio en blanco antes de ella. Si no, inserta un nuevo ``\``. Sin embargo, la última línea de la región se trata de forma especial; no se inserta ningún ``\`` en esa línea, y cualquier ``\`` que haya se borra. :kbd:`Alt`-:kbd:`x` ``cpp-highlight-buffer`` (``M-x cpp-highlight-buffer``) Resalta partes del texto según sus condicionales de preprocesador. Este comando muestra otro búfer llamado ``*CPP Edit*``, que sirve como menú gráfico para seleccionar cómo mostrar determinados tipos de condicionales y su contenido. Después de cambiar varios parámetros, haga clic en ``[A]pply these settings`` ([A]plique estos parámetros) (o vaya a ese búfer y escriba ``a)`` para volver a resaltar el búfer del modo C en consecuencia. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`s` (``C-c C-s``) Muestra la información sintáctica de la línea fuente actual (``c-show-syntactic-information``). Esta información indica cómo se aplica la sangría a la línea. | :kbd:`Alt`-:kbd:`x` ``cwarn-mode`` (``M-x cwarn-mode``) | :kbd:`Alt`-:kbd:`x` ``global-cwarn-mode`` (``M-x global-cwarn-mode``) El modo menor de CWarn resalta ciertas construcciones sospechosas de C y C++: * Asignaciones dentro de expresiones. * Punto y coma inmediatamente después de ``if``, ``for``, y ``while`` (excepto después de una sentencia ``do ... while``); * Funciones C++ con parámetros de referencia. Puede activar el modo para un búfer con el comando ``M-x cwarn-mode``, o para todos los búferes adecuados con el comando ``M-x global-cwarn-mode`` o personalizando la variable ``global-cwarn-mode``. También debe habilitar el modo Font Lock para que funcione. :kbd:`Alt`-:kbd:`x` ``hide-ifdefmode`` (``M-x hide-ifdef-mode``) El modo menor Hide-ifdef oculta el código seleccionado dentro de los bloques de preprocesador ``#if`` y ``#ifdef``. Si cambia la variable ``hide-ifdef-shadow`` a ``t``, Hide-ifdef minor mode sombrea los bloques de preprocesador mostrándolos con una cara menos prominente, en lugar de ocultarlos por completo. Consulte la cadena de documentación de ``hide-ifdef-mode`` para más información. :kbd:`Alt`-:kbd:`x` ``ff-findrelated-file`` (``M-x ff-find-related-file``) Busca un archivo relacionado de forma especial con el archivo visitado por el búfer actual. Normalmente será el archivo de cabecera correspondiente a un archivo fuente C/C++, o viceversa. La variable ``ff-related-file-alist`` especifica cómo calcular los nombres de archivos relacionados. 27.13 Modo Asm ============== El modo Asm es un modo principal para editar archivos de código ensamblador. Define estos comandos: :kbd:`TAB` (``TAB``) ``tab-to-tab-stop``. :kbd:`Ctrl`-:kbd:`j` (``C-j``) Inserta una nueva línea y luego aplica indentación usando ``tab-to-tab-stop``. :kbd:`:` (``:``) Introduce dos puntos y, a continuación, elimina la sangría de antes de los dos puntos de la etiqueta anterior. A continuación, hace ``tab-to-tab-stop``. :kbd:`;` (``;``) Inserta o alinea un comentario. La variable asm-comment-char especifica qué carácter inicia los comentarios en la sintaxis de ensamblador. .. _27.14: 27.14 Modo Fortran ================== El modo Fortran está pensado para editar código fuente de forma fija (y también de formato tabulado) (normalmente Fortran 77). Para editar código fuente de forma libre más moderno (Fortran 90, 95, 2003, 2008), use el modo F90 (``f90-mode``). Emacs normalmente usa el modo Fortran para archivos con extensión ``.f``, ``.F`` o ``.for``, y el modo F90 para las extensiones ``.f90``, ``.f95``, ``.f03`` y ``.f08``. Personalice ``auto-mode-alist`` para añadir más extensiones. GNU Fortran soporta tanto el modo libre como el fijo. Este manual documenta principalmente el modo Fortran, pero las características correspondientes del modo F90 se mencionan cuando son relevantes. El modo Fortran proporciona comandos especiales de movimiento para sentencias y subprogramas Fortran, y comandos de sangrado que entienden las convenciones Fortran de anidamiento, números de línea y sentencias de continuación. El modo Fortran es compatible con el modo Auto Relleno (Auto Fill mode), que divide las líneas largas en líneas de continuación Fortran adecuadas. El modo Fortran también admite el modo Hideshow minor (véase :ref:`27.7`) e Imenu (véase :ref:`27.2.3`). Se proporcionan comandos especiales para los comentarios porque los comentarios de Fortran no son como los de otros lenguajes. Las abreviaturas incorporadas ahorran teclear cuando se insertan palabras clave de Fortran. Use ``M-x fortran-mode`` para cambiar a este modo principal. Este comando ejecuta el gancho ``fortran-mode-hook``. Consulte :ref:`50.2.2`. 27.14.1 Comandos de Movimie --------------------------- Además de los comandos normales para moverse por defuns y operar sobre ellos (subprogramas-funciones y subrutinas de Fortran, así como módulos para el modo F90, usando los comandos ``fortran-end-of-subprogram`` y ``fortran-beginning-of-subprogram``), el modo Fortran proporciona comandos especiales para moverse por sentencias y otras unidades de programa. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`n` (``C-c C-n``) Se mueve al principio de la siguiente sentencia (``fortran-next-statement``/``f90-next-statement``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`p` (``C-c C-p``) Se desplaza al principio de la sentencia anterior (``fortran-previous-statement``/``f90-previous-statement``). Si no hay sentencia anterior (es decir, si se llama desde la primera sentencia del búfer), se desplaza al principio del búfer. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`e` (``C-c C-e``) Avanza el punto hasta el inicio del siguiente bloque de código, o hasta el final del actual, lo que ocurra primero (``f90-next-block``). Un bloque de código es una subrutina, una sentencia ``if-endif``, etc. Este comando sólo existe en modo F90, no en modo Fortran. Con un argumento numérico, avanza el mismo número de bloques. :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`a` (``C-c C-a``) Mueve el punto hacia atrás hasta el bloque anterior (``f90-previous-block``). Es como ``f90-next-block``, pero se mueve hacia atrás. :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`n` (``C-M-n``) Se desplaza al final del bloque de código actual (``fortran-end-of-block``/``f90-end-of-block``). Con un argumento numérico, avanza ese número de bloques. La marca se fija antes de mover el punto. La versión en modo F90 de este comando comprueba la coherencia de los tipos de bloque y las etiquetas (si están presentes), pero no comprueba el bloque más externo ya que puede estar incompleto. :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`p` (``C-M-p``) Se mueve al principio del bloque de código actual (``fortran-beginning-of-block``/``f90-beginning-of-block``). Es como ``fortran-end-of-block``, pero se mueve hacia atrás. Las órdenes ``fortran-beginning-of-subprogram`` y ``fortran-end-of-subprogram`` se desplazan al inicio o al final del subprograma actual, respectivamente. Las órdenes ``fortran-mark-do`` y ``fortran-mark-if marcan`` el final del bloque actual ``do`` o ``if``, y desplazan el punto al principio. .. _27.14.2: 27.14.2. Indentación en Fortran ------------------------------- Se necesitan comandos y características especiales para sangrar código Fortran de forma fija (o tabulador) para asegurarse de que varias entidades sintácticas (números de línea, indicadores de línea de comentario y banderas de línea de continuación) aparecen en las columnas requeridas. 27.14.2.1. Comandos Fortran de Indentado y Relleno ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`j` (``C-M-j``) Rompe la línea actual en un punto y establece una línea de continuación (``fortran-split-line``). :kbd:`Alt`-:kbd:`^` (``M-^``) Une esta línea a la anterior (``fortran-join-line``). :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`q` (``C-M-q``) Indenta todas las líneas del subprograma en el que se encuentra ese punto (``fortran-indent-subprogram``). :kbd:`Alt`-:kbd:`q` (``M-q``) Rellena un bloque de comentarios o una sentencia (usando ``fortran-fill-paragraph`` o ``fortran-fill-statement``). La combinación de teclas :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`q` (``C-M-q``) ejecuta ``fortran-indent-subprogram``, una orden para volver a sangrar todas las líneas del subprograma Fortran (función o subrutina) que contiene el punto. La combinación de teclas :kbd:`Ctrl`-:kbd:`Alt`-:kbd:`j` (``C-M-j``) ejecuta ``fortran-split-line``, que divide una línea de la forma adecuada para Fortran. En una línea sin comentario, la segunda mitad se convierte en una línea de continuación y se sangra en consecuencia. En una línea de comentario, ambas mitades se convierten en líneas de comentario separadas. ``M-^`` o ``C-c C-d`` ejecutan el comando ``fortran-join-line``, que une una línea de continuación con la línea anterior, más o menos como la inversa de ``fortran-split-line``. El punto debe estar en una línea de continuación cuando se invoque este comando. ``M-q`` en modo Fortran rellena el bloque de comentarios o la sentencia en la que se encuentra el punto. Esto elimina cualquier continuación de sentencia sobrante. .. _27.14.2.2: 27.14.2.2. Líneas de Continuación ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ La mayoría de los compiladores de Fortran 77 permiten dos formas de escribir líneas de continuación. Si el primer carácter no espaciador de una línea está en la columna 5, entonces esa línea es una continuación de la línea anterior. A esto lo llamamos *forma fija*. (En GNU Emacs siempre contamos las columnas a partir de 0; pero tenga en cuenta que el estándar Fortran cuenta a partir de 1. Puede personalizar la variable ``column-number-indicator-zero-based`` para hacer que la visualización de la columna sea similar a Fortran; vea :ref:`15.19`). La variable ``fortran-continuation-string`` especifica qué carácter poner en la columna 5. Una línea que comienza con un carácter de tabulación seguido de cualquier dígito excepto ``0`` es también una línea de continuación. Llamamos a este estilo de continuación *formato tabulador*. (Fortran 90 introdujo las líneas de continuación de forma libre). El modo Fortran puede usar cualquier estilo de línea de continuación. Cuando se entra en el modo Fortran, éste intenta deducir automáticamente el estilo de continuación apropiado a partir del contenido del búfer. Para ello, explora hasta 100 líneas desde el inicio del búfer. La primera línea que comienza con un tabulador o seis espacios determina la elección. Si el escaneo falla (por ejemplo, si el búfer es nuevo y, por tanto, está vacío), se usa el valor de ``fortran-tab-mode-default`` (``nil`` para la forma fija y no ``nil`` para el formato tab). ``/t`` (``fortran-tab-mode-string``) en la línea mode indica que se ha seleccionado el formato tab. El modo Fortran establece el valor de indent-tabs-mode en consecuencia. Si el texto de una línea comienza con el marcador de continuación de Fortran ``$``, o si comienza con cualquier carácter que no sea un espacio en blanco en la columna 5, el modo Fortran lo trata como una línea de continuación. Cuando indenta una línea de continuación con ``TAB``, convierte la línea al estilo de continuación actual. Al dividir una sentencia Fortran con ``C-M-j``, el marcador de continuación en la nueva línea se crea según el estilo de continuación. La configuración del estilo de continuación afecta a otros aspectos de la edición en modo Fortran. En el modo de formato fijo, el número mínimo de columna para el cuerpo de una sentencia es 6. Las líneas dentro de bloques de Fortran que están sangradas a números de columna mayores deben usar sólo el carácter de espacio como espacio en blanco. En el modo de formato tabulado, el número mínimo de columna para el cuerpo de la sentencia es 8, y el espacio en blanco antes de la columna 8 debe consistir en un carácter de tabulación. 27.14.2.3. Números de Línea ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Si un número es el primer no-espacio en blanco de la línea, la indentación de Fortran asume que es un número de línea y lo mueve a las columnas 0 a 4. (Las columnas siempre cuentan desde 0 en Emacs, pero establecer ``column-number-indicator-zero-based`` a ``nil`` puede cambiar esto, vea :ref:`15.19`). Los números de línea de cuatro dígitos o menos tienen normalmente una sangría de un espacio. La variable ``fortran-line-number-indent`` controla esto; especifica la sangría máxima que puede tener un número de línea. El valor por defecto de la variable es 1. El modo Fortran intenta evitar que los dígitos del número de línea pasen de la columna 4, reduciendo la sangría por debajo del máximo especificado si es necesario. Si ``fortran-line-number-indent`` tiene el valor 5, los números de línea se justifican a la derecha para terminar en la columna 4. La simple inserción de un número de línea es suficiente para sangrarlo de acuerdo con estas reglas. A medida que se inserta cada dígito, se vuelve a calcular la sangría. Para desactivar esta función, establezca la variable ``fortran-electric-number-line`` a ``nil``. 27.14.2.4 Convenciones Sintácticas ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ El modo Fortran asume que Usted sigue ciertas convenciones que simplifican la tarea de entender un programa Fortran lo suficientemente bien como para sangrarlo adecuadamente: * Dos bucles ``do`` anidados nunca comparten una sentencia ``continue``. Las palabras clave de Fortran como ``if``, ``else``, ``then``, ``do`` y otras se escriben sin espacios en blanco ni saltos de línea. * Los compiladores de Fortran suelen ignorar los espacios en blanco fuera de las constantes de cadena, pero el modo Fortran no reconoce estas palabras clave si no son contiguas. Construcciones como ``else`` ``if`` o ``end do`` son aceptables, pero la segunda palabra debe estar en la misma línea que la primera y no en una línea de continuación. Si no sigue estas convenciones, los comandos de sangrado pueden sangrar algunas líneas de forma poco estética. Sin embargo, un programa Fortran correcto conserva su significado cuando se le aplica la sangría aunque no se sigan las convenciones. 27.14.2.5. Variables para el Indentado en Fortran ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Varias variables adicionales controlan cómo funciona la sangría en Fortran: ``fortran-do-indent`` Indentación extra dentro de cada nivel de la sentencia ``do`` (por defecto 3). ``fortran-if-indent`` Indentación extra dentro de cada nivel de sentencias ``if``, ``select case``, o ``where`` (por defecto 3). ``fortran-structure-indent`` Indentación extra dentro de cada nivel de sentencias ``structure``, ``union``, ``map``, o ``interface`` (por defecto 3). ``fortran-continuation-indent`` Sangría adicional para los cuerpos de las líneas de continuación (por defecto 5). ``fortran-check-all-num-for-matching-do`` En Fortran 77, una sentencia ``do`` numerada es terminada por cualquier sentencia con un número de línea coincidente. Es común (pero no obligatorio) usar una sentencia ``continue`` para este propósito. Si esta variable tiene un valor no nulo, la indentación de cualquier sentencia numerada debe comprobar si hay una ``do`` que termine ahí. Si siempre termina las sentencias ``do`` con una línea ``continue`` (o si usa el más moderno ``enddo``), entonces puede acelerar la indentación estableciendo esta variable a ``nil`` (por defecto). ``fortran-blink-matching-if`` Si es ``t``, al indentar una sentencia ``endif`` (o ``enddo``) el cursor se mueve momentáneamente a la sentencia ``if`` (o ``do``) correspondiente para mostrar dónde está. Por defecto es ``nil``. ``fortran-minimum-statement-indent-fixed`` Indentación mínima para sentencias Fortran cuando se usa el estilo de línea de continuación de forma fija. Los cuerpos de las sentencias nunca tienen una sangría menor. El valor por defecto es 6. ``fortran-minimum-statement-indent-tab`` Indentación mínima de las sentencias Fortran para el estilo de línea de continuación del formato tabulador. Los cuerpos de las sentencias nunca tienen una sangría menor. El valor predeterminado es 8. La siguiente sección describe las variables que controlan la sangría de los comentarios. 27.14.3. Comentarios en Fortran ------------------------------- Las órdenes de comentario habituales de Emacs asumen que un comentario puede seguir a una línea de código. En Fortran 77, la sintaxis de comentario estándar requiere que una línea entera sea sólo un comentario. Por lo tanto, el modo Fortran sustituye las órdenes de comentario estándar de Emacs y define algunas variables nuevas. El modo Fortran también puede manejar la sintaxis de comentarios de Fortran 90, en la que los comentarios empiezan por ``!`` y pueden seguir a otro texto. Dado que sólo algunos compiladores de Fortran 77 aceptan esta sintaxis, el modo Fortran no insertará tales comentarios a menos que Usted haya dicho de antemano que lo haga. Para ello, ajuste la variable ``fortran-comment-line-start`` a ``"!"``. Si usa un valor inusual, puede que necesite cambiar ``fortran-comment-line-start-skip``. :kbd:`Alt`-:kbd:`p` (``M-;``) Permite alinear un comentario o insertar uno nuevo (``comment-dwim``). :kbd:`Ctrl`-:kbd:`x` :kbd:`;` (``C-x ;``) Sólo se aplica a los comentarios ``!`` no estándar (``comment-set-column``). :kbd:`Ctrl`-:kbd:`c` :kbd:`;` (``C-c ;``) Convierte todas las líneas de la región en comentarios, o (con argumento) las convierte de nuevo en código real (``fortran-comment-region``). ``M-;`` en modo Fortran ejecuta el comando ``comment-dwim`` estándar. Este reconoce cualquier tipo de comentario existente y alinea su texto adecuadamente; si no hay comentario existente, se inserta y alinea un comentario. Insertar y alinear comentarios no es lo mismo en modo Fortran que en otros modos. Cuando hay que insertar un nuevo comentario, si la línea actual está en blanco, se inserta un comentario de línea completa. En una línea que no esté en blanco, se inserta un comentario ``!`` no estándar si ha dicho que quiere usarlos. En caso contrario, se inserta un comentario de línea completa en una nueva línea antes de la línea actual. Los comentarios ``!`` no estándar se alinean como los comentarios en otros idiomas, pero los comentarios de línea completa son diferentes. En un comentario de línea completa estándar, el delimitador del comentario debe aparecer siempre en la columna cero. Lo que puede alinearse es el texto dentro del comentario. Puede elegir entre tres estilos de alineación ajustando la variable ``fortran-comment-indent-style`` a uno de estos valores: ``fixed`` Alinea el texto en una columna fija, que es la suma de ``fortran-comment-line-extra-indent`` y la sangría mínima de la sentencia. Este es el valor por defecto. La sangría mínima es ``fortran-minimum-statement-indent-tab`` para el estilo de línea de continuación con formato tabulador y ``fortran-minimum-statement-indent-fixed`` para el estilo de formulario fijo. ``relative`` Alinea el texto como si fuera una línea de código, pero con una columna adicional de sangría ``fortran-comment-line-extra-indent``. ``nil`` No mueve automáticamente el texto en los comentarios de línea completa. Además, puede especificar el carácter que se usará para sangrar dentro de los comentarios de línea completa estableciendo la variable ``fortran-comment-indent-char`` en la cadena de un solo carácter que desee usar. Las líneas de directivas del compilador, o líneas del preprocesador, tienen prácticamente la misma apariencia que las líneas de comentario. Es importante, sin embargo, que dichas líneas nunca tengan sangría, sea cual sea el valor de ``fortran-comment-indent-style``. La variable ``fortran-directive-re`` es una expresión regular que especifica qué líneas son directivas. Las líneas que coincidan nunca se sangrarán y recibirán un bloqueo de fuente distintivo. El comando de comentario normal de Emacs ``C-x ;`` (``comment-set-column``) no ha sido redefinido. Si usa comentarios ``!``, este comando puede usarse con ellos. De lo contrario, es inútil en modo Fortran. El comando ``C-c ;`` (``fortran-comment-region``) convierte todas las líneas de la región en comentarios insertando la cadena ``c$$$`` al principio de cada una. Con un argumento numérico, convierte la región de nuevo en código dinámico borrando ``c$$$`` del principio de cada línea. La cadena usada para estos comentarios puede controlarse estableciendo la variable ``fortran-comment-region``. Observe que aquí tenemos un ejemplo de un comando y una variable con el mismo nombre; estos dos usos del nombre nunca entran en conflicto porque en Lisp y en Emacs siempre queda claro por el contexto a cuál de los dos se refiere. 27.14.4. Relleno Automático en Modo Fortran ------------------------------------------- El modo Fortran tiene soporte especializado para el modo Auto Fill, que es un modo menor que divide automáticamente las sentencias a medida que las inserta cuando se vuelven demasiado anchas. Dividir una sentencia implica hacer líneas de continuación usando ``fortran-continuation-string`` (vea :ref:`27.14.2.2`). Esta división se produce cuando escribe :kbd:`SPACE` (``SPC``), :kbd:`RETURN` (``RET``) o :kbd:`TAB` (``TAB``), y también en los comandos de indentación de Fortran. Active Auto Fill en modo Fortran de la forma habitual. Véase :ref:`26.6.1`). Relleno Automático (Auto Fill) rompe las líneas en los espacios o delimitadores cuando las líneas superan la anchura deseada (el valor de ``fill-column``). Los delimitadores (además de los espacios en blanco) con los que Auto Fill puede romper son ``+``, ``-``, ``/``, ``*``, ``=``, ``<``, ``>`` y ``,``. El salto de línea se produce después del delimitador si la variable ``fortran-break-before-delimiters`` es nula. En caso contrario (y por defecto), el salto va antes del delimitador. Para activar el relleno automático en todos los búferes de Fortran, añada ``auto-fill-mode`` a ``fortran-mode-hook``. Véase :ref:`50.2.2`. 27.14.5. Comprobación de Columnas en Fortran -------------------------------------------- En Fortran 77 estándar, cualquier cosa más allá de la columna 72 se ignora. La mayoría de los compiladores proporcionan una opción para cambiar esto (por ejemplo, ``-ffixed-line-length-N`` en gfortran). Personalice la variable fortran-line-length para cambiar la longitud de línea en modo Fortran. Cualquier cosa más allá de este punto se bloquea como un comentario. (A menos que esté dentro de una cadena: las cadenas que se extiendan más allá de ``fortran-line-length`` confundirán el bloqueo de fuentes (font-lock)). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`r` (``C-c C-r``) Muestra una regla de columnas momentáneamente sobre la línea actual (``fortran-column-ruler``). :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`w` (``C-c C-w``) Divide la ventana actual horizontalmente de forma temporal para que tenga columnas de longitud de línea fortran (``fortran-window-create-momentarily``). Esto puede ayudarle a evitar hacer líneas más largas que el límite impuesto por su compilador de Fortran. :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`c` :kbd:`Ctrl`-:kbd:`w` (``C-u C-c C-w``) Divide la ventana actual horizontalmente para que tenga columnas de longitud de línea de fortran de ancho (``fortran-window-create``). A continuación, puede seguir editando. :kbd:`Alt`-:kbd:`x` (``M-x`` ``fortran-strip-sequence-nos``) Borra todo el texto de la columna ``fortran-longitud`` de línea y posteriores. El comando ``C-c C-r`` (``fortran-column-ruler``) muestra una regla de columnas momentáneamente sobre la línea actual. La regla de comentarios son dos líneas de texto que muestran la ubicación de las columnas con un significado especial en los programas Fortran. Los corchetes muestran los límites de las columnas para los números de línea, y las llaves muestran los límites de las columnas para el cuerpo de la sentencia. Los números de columna aparecen sobre ellos. Tenga en cuenta que los números de columna cuentan desde cero, como siempre en GNU Emacs (pero personalizando ``column-number-indicator-zero-based`` puede cambiar la visualización de las columnas para que coincida con la de Fortran; vea :ref:`15.19`). Como resultado, los números pueden ser uno menos que aquellos con los que está familiarizado; pero las posiciones que indican en la línea son estándar para Fortran. El texto usado para mostrar la regla de columna depende del valor de la variable ``indent-tabs-mode``. Si ``indent-tabs-mode`` es ``nil``, entonces se usa el valor de la variable ``fortran-column-ruler-fixed`` como regla de columna. En caso contrario, se muestra el valor de la variable ``fortran-column-ruler-tab``. Cambiando estas variables, puede cambiar la visualización de la regla de columna. ``C-c C-w`` (``fortran-window-create-momentarily``) divide temporalmente la ventana actual horizontalmente, haciendo una ventana de columnas de longitud de línea fortran, para que pueda ver las líneas demasiado largas. Escriba un espacio para restaurar el ancho normal. También puede dividir la ventana horizontalmente y continuar editando con la división en su lugar. Para usar esto, use ``C-u C-c C-w`` (``M-x fortran-window-create``). Editando en esta ventana puede ver inmediatamente cuando hace una línea demasiado ancha para ser Fortran correcto. El comando ``M-x fortran-strip-sequence-nos`` borra todo el texto de la columna ``fortran-line-length`` y posteriores, en todas las líneas del búfer actual. Esta es la forma más fácil de deshacerse de números de secuencia antiguos. 27.14.6. Abreviaturas de Palabras Clave en Fortran -------------------------------------------------- El modo Fortran proporciona muchas abreviaturas incorporadas para palabras clave y declaraciones comunes. Son el mismo tipo de abreviaturas que puede definir Usted mismo. Para usarlas, debe activar el modo Abbrev. Véase :ref:`30`. Las abreviaturas incorporadas son inusuales en un sentido: todas empiezan por punto y coma. Por ejemplo, una abreviatura incorporada en Fortran es ``;c`` para ``continue`` (continuar). Si inserta ``;c`` y luego inserta un carácter de puntuación como un espacio o una nueva línea, la ``;c`` se expande automáticamente a ``continue``, siempre que el modo Abbrev esté activado. Escriba :kbd:`;`:kbd:`?` (``;?``) o :kbd:`Ctrl`:kbd:`h` (``;C-h``) para ver una lista de todas las abreviaturas de Fortran y lo que significan.