<p>A menudo puede usar una característica llamada <em>completado</em> para ayudar a introducir argumentos. Esto significa que después de teclear parte del argumento, Emacs puede rellenar el resto, o parte de él, basándose en lo tecleado hasta el momento.</p>
<p>Cuando el completado está disponible, ciertas teclas (normalmente <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>), <kbdclass="kbd docutils literal notranslate">RETURN</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code>), y <kbdclass="kbd docutils literal notranslate">SPACE</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">SPC</span></code>)) son redirigidas en el minibuffer a comandos
especiales de completado ver <aclass="reference internal"href="#id5"><spanclass="std std-ref">9.4.2 Comandos de Completado</span></a>). Estos comandos intentan completar el texto en el minibuffer, basándose en un conjunto de <em>alternativas de completado</em> proporcionadas por el comando que solicitó el argumento. Normalmente puede teclear <kbdclass="kbd docutils literal notranslate">?</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">?</span></code>) para ver una lista de alternativas de completado.</p>
<p>Aunque el completado normalmente se lleva a cabo en el minibuffer, a veces esta función también está disponible en los buffers normales. Véase <aclass="reference internal"href="27_EdDePrograms.html#id22"><spanclass="std std-ref">27.8 Completado de Nombres de Símbolos</span></a>.</p>
<p>Aunque el completado normalmente se lleva a cabo en el minibuffer, a veces esta función también está disponible en los buffers normales. Véase <aclass="reference internal"href="27_EdDePrograms.html#id23"><spanclass="std std-ref">27.8 Completado de Nombres de Símbolos</span></a>.</p>
<sectionid="ejemplos-de-completado">
<h3>9.4.1 Ejemplos de Completado<aclass="headerlink"href="#ejemplos-de-completado"title="Link to this heading"></a></h3>
<p>Un simple ejemplo puede ser de ayuda. <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span></code>) usa el minibuffer para leer el nombre de un comando, por lo que el completado funciona comparando el texto del minibuffer con los nombres de los comandos Emacs existentes. Suponga que desea ejecutar el comando auto-fill-mode. Puede hacerlo tecleando <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><codeclass="docutils literal notranslate"><spanclass="pre">auto-fill-mode</span></code><kbdclass="kbd docutils literal notranslate">RETURN</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span></code><codeclass="docutils literal notranslate"><spanclass="pre">auto-fill-mode</span></code><codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code>), pero es más fácil usar el completado.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">M-@</span></code>, (<codeclass="docutils literal notranslate"><spanclass="pre">mark-word</span></code>, marcar palabra) coloca la marca al final de la palabra siguiente (véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id2"><spanclass="std std-ref">26.1 Palabras</span></a>, para obtener información sobre las palabras). Las invocaciones repetidas de este comando amplían la región haciendo avanzar la marca una palabra cada vez. Como excepción, si la marca está activa y situada antes del punto, <codeclass="docutils literal notranslate"><spanclass="pre">M-@</span></code> desplaza la marca hacia atrás desde su posición actual una palabra cada vez.</p>
<p>Este comando también acepta un argumento numérico <em>n</em>, que le indica que avance la marca <em>n</em> palabras. Un argumento negativo <em>-n</em> hace retroceder la marca <em>n</em> palabras.</p>
<p>Del mismo modo, <codeclass="docutils literal notranslate"><spanclass="pre">C-M-@</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">marca-sexp</span></code>) coloca la marca al final de la siguiente expresión equilibrada (véase <aclass="reference internal"href="27_EdDePrograms.html#id10"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>). Las invocaciones repetidas extienden la región a expresiones posteriores, mientras que los argumentos numéricos positivos o negativos desplazan la marca hacia delante o hacia atrás el número de expresiones especificado.</p>
<p>Del mismo modo, <codeclass="docutils literal notranslate"><spanclass="pre">C-M-@</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">marca-sexp</span></code>) coloca la marca al final de la siguiente expresión equilibrada (véase <aclass="reference internal"href="27_EdDePrograms.html#id11"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>). Las invocaciones repetidas extienden la región a expresiones posteriores, mientras que los argumentos numéricos positivos o negativos desplazan la marca hacia delante o hacia atrás el número de expresiones especificado.</p>
<p>Los demás comandos de la lista anterior establecen tanto el punto como la marca, para delimitar un objeto en el búfer. <codeclass="docutils literal notranslate"><spanclass="pre">M-h</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">mark-paragraph</span></code>) marca párrafos (véase véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id5"><spanclass="std std-ref">26.4 Páginas</span></a>), <codeclass="docutils literal notranslate"><spanclass="pre">C-M-h</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">mark-defun</span></code>) marca definiciones de nivel superior (véase <aclass="reference internal"href="27_EdDePrograms.html#id2"><spanclass="std std-ref">27.2 Definiciones de Nivel Superior, o Defuns</span></a>), y <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">C-p</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">mark-page</span></code>) marca páginas. Las invocaciones repetidas juegan de nuevo el mismo papel, extendiendo la región a objetos consecutivos; de forma similar, los argumentos numéricos especifican por cuántos objetos mover la marca.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">h</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">mark-whole-buffer</span></code>) establece todo el buffer como región, poniendo el punto al principio y la marca al final.</p>
<p>20 Mata hasta, pero sin incluir, la siguiente aparición de <em>caracter</em>.</p>
<p>Uno de los comandos de eliminación más usados es <codeclass="docutils literal notranslate"><spanclass="pre">C-w</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">kill-region</span></code>), que elimina el texto de la región (véase <aclass="reference internal"href="12_LaMarca-y-LaRegion.html#id1"><spanclass="std std-ref">12 La marca y la región</span></a>). Del mismo modo, <codeclass="docutils literal notranslate"><spanclass="pre">M-w</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">kill-ring-save</span></code>) copia el texto de la región en el anillo de muertes sin eliminarlo del búfer. Si la marca está inactiva cuando teclea <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">w</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-w</span></code>) o <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">w</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-w</span></code>), el comando actúa sobre el texto entre el punto y donde puso la marca por última vez (ver <aclass="reference internal"href="12_LaMarca-y-LaRegion.html#id6"><spanclass="std std-ref">12.3 Operar en la Región</span></a>).</p>
<p>Emacs también proporciona comandos para matar unidades sintácticas específicas: palabras, con <codeclass="docutils literal notranslate"><spanclass="pre">M-DEL</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">M-d</span></code> (vea <aclass="reference internal"href="26_ComandsLengsHuma.html#id2"><spanclass="std std-ref">26.1 Palabras</span></a>); expresiones compuestas, con <codeclass="docutils literal notranslate"><spanclass="pre">C-M-k</span></code> (vea <aclass="reference internal"href="27_EdDePrograms.html#id10"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>); y frases, con <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">DEL</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">M-k</span></code> (vea <aclass="reference internal"href="26_ComandsLengsHuma.html#id3"><spanclass="std std-ref">26.2 Frases (u oraciones)</span></a>).</p>
<p>Emacs también proporciona comandos para matar unidades sintácticas específicas: palabras, con <codeclass="docutils literal notranslate"><spanclass="pre">M-DEL</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">M-d</span></code> (vea <aclass="reference internal"href="26_ComandsLengsHuma.html#id2"><spanclass="std std-ref">26.1 Palabras</span></a>); expresiones compuestas, con <codeclass="docutils literal notranslate"><spanclass="pre">C-M-k</span></code> (vea <aclass="reference internal"href="27_EdDePrograms.html#id11"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>); y frases, con <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">DEL</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">M-k</span></code> (vea <aclass="reference internal"href="26_ComandsLengsHuma.html#id3"><spanclass="std std-ref">26.2 Frases (u oraciones)</span></a>).</p>
<p>El comando <codeclass="docutils literal notranslate"><spanclass="pre">M-z</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">zap-to-char</span></code>) combina matar con buscar: lee un carácter y mata desde el punto hasta (e incluyendo) la siguiente aparición de ese carácter en el búfer. Un argumento numérico actúa como contador de repeticiones; un argumento negativo significa buscar hacia atrás y matar el texto anterior al punto. Se mantiene un historial de los caracteres usados anteriormente, al que se puede acceder mediante las teclas <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">p</kbd> / <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">n</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-p</span></code>/<codeclass="docutils literal notranslate"><spanclass="pre">M-n</span></code>). Esto es útil sobre todo si el carácter que se va a utilizar tiene que introducirse mediante un método de entrada complicado. Un comando similar <codeclass="docutils literal notranslate"><spanclass="pre">zap-up-to-char</span></code> mata desde el punto hasta, pero sin incluir, la siguiente aparición de un carácter, con un argumento numérico que actúa como contador de repeticiones.</p>
<p>El error común de transponer dos caracteres puede solucionarse, cuando son adyacentes, con el comando <codeclass="docutils literal notranslate"><spanclass="pre">C-t</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">transpose-chars</span></code>). Normalmente, <codeclass="docutils literal notranslate"><spanclass="pre">C-t</span></code> transpone los dos caracteres a ambos lados del punto. Cuando se da al final de una línea, en lugar de transponer el último carácter de la línea con la nueva línea, lo que sería inútil, <codeclass="docutils literal notranslate"><spanclass="pre">C-t</span></code> transpone los dos últimos caracteres de la línea. Por lo tanto, si detecta el error de transposición enseguida, puede solucionarlo con <codeclass="docutils literal notranslate"><spanclass="pre">C-t</span></code>. Si no lo detecta tan rápido, debe volver a colocar el cursor entre los dos caracteres transpuestos antes de teclear <codeclass="docutils literal notranslate"><spanclass="pre">C-t</span></code>. Si ha transpuesto un espacio con el último carácter de la palabra delante, los comandos de movimiento de palabra (<codeclass="docutils literal notranslate"><spanclass="pre">M-f</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">M-b</span></code>, etc.) son una buena forma de llegar hasta allí. De lo contrario, una búsqueda inversa (<codeclass="docutils literal notranslate"><spanclass="pre">C-r</span></code>) suele ser la mejor manera. Véase <aclass="reference internal"href="16_BusqReemp.html#id1"><spanclass="std std-ref">16 Búsqueda y Reemplazo</span></a>.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">M-t</span></code> transpone la palabra antes del punto con la palabra después del punto (<codeclass="docutils literal notranslate"><spanclass="pre">transpose-words</span></code>). Desplaza el punto hacia delante sobre una palabra, arrastrando también hacia delante la palabra que precede o contiene al punto. Los caracteres de puntuación entre las palabras no se mueven. Por ejemplo, <codeclass="docutils literal notranslate"><spanclass="pre">FOO,</span><spanclass="pre">BAR</span></code> se transpone a <codeclass="docutils literal notranslate"><spanclass="pre">BAR,</span><spanclass="pre">FOO</span></code> en lugar de <codeclass="docutils literal notranslate"><spanclass="pre">BAR</span><spanclass="pre">FOO,</span></code>. Si el punto se encuentra al final de la línea, la palabra anterior al punto se transpondrá con la primera palabra de la línea siguiente.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">C-M-t</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">transpose-sexps</span></code>) es un comando similar para transponer dos expresiones (véase <aclass="reference internal"href="27_EdDePrograms.html#id10"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>), y <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">C-t</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">transpose-lines</span></code>) intercambia líneas. <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">transpose-sentences</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">transpose-paragraphs</span></code> transponen frases y párrafos, respectivamente. Estos comandos funcionan como <codeclass="docutils literal notranslate"><spanclass="pre">M-t</span></code> excepto en lo que respecta a las unidades de texto que transponen.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">C-M-t</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">transpose-sexps</span></code>) es un comando similar para transponer dos expresiones (véase <aclass="reference internal"href="27_EdDePrograms.html#id11"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>), y <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">C-t</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">transpose-lines</span></code>) intercambia líneas. <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">transpose-sentences</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">transpose-paragraphs</span></code> transponen frases y párrafos, respectivamente. Estos comandos funcionan como <codeclass="docutils literal notranslate"><spanclass="pre">M-t</span></code> excepto en lo que respecta a las unidades de texto que transponen.</p>
<p>Un argumento numérico para un comando de transposición sirve como recuento de repeticiones: indica al comando de transposición que mueva el carácter (o palabra o expresión o línea) anterior o que contenga el punto a través de varios otros caracteres (o palabras o expresiones o líneas). Por ejemplo, <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">u</kbd><kbdclass="kbd docutils literal notranslate">3</kbd><kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">t</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">3</span><spanclass="pre">C-t</span></code>) desplaza el carácter anterior al punto hacia adelante a través de otros tres caracteres. Cambiaría <codeclass="docutils literal notranslate"><spanclass="pre">f∗oobar</span></code> por <codeclass="docutils literal notranslate"><spanclass="pre">oobf∗ar</span></code>. Esto equivale a repetir <codeclass="docutils literal notranslate"><spanclass="pre">C-t</span></code> tres veces. <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">u</kbd><kbdclass="kbd docutils literal notranslate">-</kbd><kbdclass="kbd docutils literal notranslate">4</kbd><kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">t</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">-</span><spanclass="pre">4</span><spanclass="pre">M-t</span></code>) mueve la palabra anterior al punto anterior a través de cuatro palabras. <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">u</kbd><kbdclass="kbd docutils literal notranslate">-</kbd><kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">t</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">-</span><spanclass="pre">C-M-t</span></code>) anularía el efecto de <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">t</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-M-t</span></code>) simple.</p>
<p>A un argumento numérico de cero se le asigna un significado especial (porque de otro modo un comando con un recuento de repeticiones de cero no haría nada): transponer el carácter (o palabra o expresión o línea) que termina después del punto con el que termina después de la marca.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">transpose-regions</span></code> transpone el texto entre el punto y la marca con el texto entre las dos últimas marcas empujado al anillo de la marca (véase <aclass="reference internal"href="12_LaMarca-y-LaRegion.html#id2"><spanclass="std std-ref">12.1 Fijar la Marca</span></a>). Con un argumento de prefijo numérico, transpone el texto entre punto y marca con el texto entre dos marcas sucesivas que muchas entradas atrás en el anillo de marca. Este comando se usa mejor para transponer varios caracteres (o palabras o frases o párrafos) de una sola vez.</p>
<p>(<codeclass="docutils literal notranslate"><spanclass="pre">ff-find-related-file</span></code> ofrece una funcionalidad similar especialmente orientada a archivos C, vea <aclass="reference internal"href="27_EdDePrograms.html#id32"><spanclass="std std-ref">27.12.4 Otros comandos para el Modo C</span></a>).</p>
<p>(<codeclass="docutils literal notranslate"><spanclass="pre">ff-find-related-file</span></code> ofrece una funcionalidad similar especialmente orientada a archivos C, vea <aclass="reference internal"href="27_EdDePrograms.html#id31"><spanclass="std std-ref">27.12.4 Otros comandos para el Modo C</span></a>).</p>
<p>O, si quiere considerar todos los ficheros bajo <codeclass="docutils literal notranslate"><spanclass="pre">"src/emacs/DIR/nombre-archivo"</span></code> como hermanos de otros <em>directorios</em>, se podría escribir:</p>
<p>Si el valor por defecto de <codeclass="docutils literal notranslate"><spanclass="pre">major-mode</span></code> es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, el modo mayor se toma del búfer previamente actual.</p>
<p>Los modos principales especializados a menudo cambian el significado de ciertas teclas para hacer algo más adecuado para el modo. Por ejemplo, los modos de lenguaje de programación vinculan <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> para sangrar la línea actual de acuerdo con las reglas del lenguaje (ver <aclass="reference internal"href="25_Indentacion.html#id1"><spanclass="std std-ref">25 Indentación</span></a>). Las teclas que suelen cambiarse son <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">DEL</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">C-j</span></code>. Muchos modos también definen comandos especiales propios, normalmente ligados a secuencias de teclas cuyo prefijo es <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">c</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-c</span></code>) (ver <aclass="reference internal"href="../03_Teclas.html#id1"><spanclass="std std-ref">3 Teclas</span></a>). Los modos principales también pueden alterar las opciones y variables del Usuario; por ejemplo, los modos de lenguaje de programación suelen establecer un valor local en el búfer para la variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-start</span></code>, que determina cómo se delimitan los comentarios del código fuente (véase <aclass="reference internal"href="27_EdDePrograms.html#id13"><spanclass="std std-ref">27.5. Manipulación de Comentarios</span></a>).</p>
<p>Los modos principales especializados a menudo cambian el significado de ciertas teclas para hacer algo más adecuado para el modo. Por ejemplo, los modos de lenguaje de programación vinculan <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> para sangrar la línea actual de acuerdo con las reglas del lenguaje (ver <aclass="reference internal"href="25_Indentacion.html#id1"><spanclass="std std-ref">25 Indentación</span></a>). Las teclas que suelen cambiarse son <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">DEL</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">C-j</span></code>. Muchos modos también definen comandos especiales propios, normalmente ligados a secuencias de teclas cuyo prefijo es <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">c</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-c</span></code>) (ver <aclass="reference internal"href="../03_Teclas.html#id1"><spanclass="std std-ref">3 Teclas</span></a>). Los modos principales también pueden alterar las opciones y variables del Usuario; por ejemplo, los modos de lenguaje de programación suelen establecer un valor local en el búfer para la variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-start</span></code>, que determina cómo se delimitan los comentarios del código fuente (véase <aclass="reference internal"href="27_EdDePrograms.html#id14"><spanclass="std std-ref">27.5. Manipulación de Comentarios</span></a>).</p>
<p>Para ver la documentación del modo principal actual, incluida una lista de sus combinaciones de teclas, escriba <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">h</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-h</span><spanclass="pre">m</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">describe-mode</span></code>). Consulte <aclass="reference internal"href="11_Ayuda.html#id7"><spanclass="std std-ref">11.8 Otros comandos de Ayuda</span></a>.</p>
<p>Cada modo principal, aparte del modo Fundamental, define un gancho (hook) de modo, una lista personalizable de funciones Lisp que se ejecutarán cada vez que se active el modo en un búfer. Para obtener más información sobre ganchos, consulte <aclass="reference internal"href="50_Personlzc.html#id7"><spanclass="std std-ref">50.2.2 Ganchos (Hooks)</span></a>. Cada gancho de modo recibe el nombre de su modo principal, por ejemplo, el modo Fortran tiene <codeclass="docutils literal notranslate"><spanclass="pre">fortran-mode-hook</span></code>. Además, todos los modos principales basados en texto ejecutan <codeclass="docutils literal notranslate"><spanclass="pre">text-mode-hook</span></code>, y muchos modos de lenguaje de programación <aclass="footnote-reference brackets"href="#id4"id="id3"role="doc-noteref"><spanclass="fn-bracket">[</span>11<spanclass="fn-bracket">]</span></a> (incluyendo todos los distribuidos con Emacs) ejecutan <codeclass="docutils literal notranslate"><spanclass="pre">prog-mode-hook</span></code>, antes de ejecutar sus propios ganchos de modo. Las funciones gancho pueden mirar el valor de la variable <codeclass="docutils literal notranslate"><spanclass="pre">major-mode</span></code> para ver en qué modo se está entrando realmente.</p>
<p>Los ganchos de modo se usan comúnmente para habilitar modos menores (vea <aclass="reference internal"href="#id5"><spanclass="std std-ref">24.2 Modos Menores</span></a>). Por ejemplo, puede poner las siguientes líneas en su archivo init para habilitar el modo menor Flyspell en todos los modos mayores basados en texto (vea <aclass="reference internal"href="17_CmdCorrecErrsTipogr.html#id6"><spanclass="std std-ref">17.4 Comprobar y Corregir la Ortografía</span></a>), y el modo menor ElDoc en el modo Emacs Lisp (vea <aclass="reference internal"href="27_EdDePrograms.html#id18"><spanclass="std std-ref">27.6.3. Búsqueda de Documentación en Lenguajes de Programación</span></a>):</p>
<p>Los ganchos de modo se usan comúnmente para habilitar modos menores (vea <aclass="reference internal"href="#id5"><spanclass="std std-ref">24.2 Modos Menores</span></a>). Por ejemplo, puede poner las siguientes líneas en su archivo init para habilitar el modo menor Flyspell en todos los modos mayores basados en texto (vea <aclass="reference internal"href="17_CmdCorrecErrsTipogr.html#id6"><spanclass="std std-ref">17.4 Comprobar y Corregir la Ortografía</span></a>), y el modo menor ElDoc en el modo Emacs Lisp (vea <aclass="reference internal"href="27_EdDePrograms.html#id19"><spanclass="std std-ref">27.6.3. Búsqueda de Documentación en Lenguajes de Programación</span></a>):</p>
<spanid="id1"></span><h1>25 Indentación<aclass="headerlink"href="#indentacion"title="Link to this heading"></a></h1>
<p>La <em>sangría</em> o <em>identación</em> se refiere a la inserción o ajuste de caracteres de <em>espacio en blanco</em> (caracteres de espacio y/o tabulación) al principio de una línea de texto. Este capítulo documenta los comandos y opciones de sangría que son comunes al modo Texto y modos relacionados, así como a los modos de lenguaje de programación. Consulte <aclass="reference internal"href="27_EdDePrograms.html#id6"><spanclass="std std-ref">27.3 Indentación de Programas</span></a>, para obtener documentación adicional sobre la indentación en los modos de programación.</p>
<p>La forma más sencilla de realizar la sangría es la tecla <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>). En la mayoría de los modos principales, esto ejecuta el comando <codeclass="docutils literal notranslate"><spanclass="pre">indent-for-tab-command</span></code>. (En C y modos relacionados, <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> ejecuta el comando <codeclass="docutils literal notranslate"><spanclass="pre">c-indent-line-or-region</span></code>, que se comporta de forma similar, ver <aclass="reference internal"href="27_EdDePrograms.html#id8"><spanclass="std std-ref">27.3.4 Comandos para la Indentación en C</span></a>).</p>
<p>La <em>sangría</em> o <em>identación</em> se refiere a la inserción o ajuste de caracteres de <em>espacio en blanco</em> (caracteres de espacio y/o tabulación) al principio de una línea de texto. Este capítulo documenta los comandos y opciones de sangría que son comunes al modo Texto y modos relacionados, así como a los modos de lenguaje de programación. Consulte <aclass="reference internal"href="27_EdDePrograms.html#id7"><spanclass="std std-ref">27.3 Indentación de Programas</span></a>, para obtener documentación adicional sobre la indentación en los modos de programación.</p>
<p>La forma más sencilla de realizar la sangría es la tecla <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>). En la mayoría de los modos principales, esto ejecuta el comando <codeclass="docutils literal notranslate"><spanclass="pre">indent-for-tab-command</span></code>. (En C y modos relacionados, <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> ejecuta el comando <codeclass="docutils literal notranslate"><spanclass="pre">c-indent-line-or-region</span></code>, que se comporta de forma similar, ver <aclass="reference internal"href="27_EdDePrograms.html#id9"><spanclass="std std-ref">27.3.4 Comandos para la Indentación en C</span></a>).</p>
<div><p>Inserta un espacio en blanco o aplica una sangría (o indentación) a la línea actual según el modo (comando sangría por tabulación). Si la
@ -231,7 +231,7 @@ grande, como este:</p>
</section>
<sectionid="funciones-practicas-para-la-sangria">
<spanid="id4"></span><h2>25.4 Funciones Prácticas para la Sangría<aclass="headerlink"href="#funciones-practicas-para-la-sangria"title="Link to this heading"></a></h2>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">tab-always-indent</span></code> modifica el comportamiento del comando <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">indent-for-tab-command</span></code> ,sangría para el comando tab). El valor por defecto, <codeclass="docutils literal notranslate"><spanclass="pre">t</span></code>, proporciona el comportamiento descrito en Sangría. Si cambia el valor por el símbolo complete, TAB intentará primero aplicar la sangría a la línea actual y, si la línea ya estaba sangrada, intentará completar el texto en el punto (véase <aclass="reference internal"href="27_EdDePrograms.html#id22"><spanclass="std std-ref">27.8 Completado de Nombres de Símbolos</span></a>). Si el valor es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> aplica sangría a la línea actual sólo si el punto está en el margen izquierdo o en la sangría de la línea; en caso contrario, inserta un carácter de tabulación.</p>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">tab-always-indent</span></code> modifica el comportamiento del comando <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">indent-for-tab-command</span></code> ,sangría para el comando tab). El valor por defecto, <codeclass="docutils literal notranslate"><spanclass="pre">t</span></code>, proporciona el comportamiento descrito en Sangría. Si cambia el valor por el símbolo complete, TAB intentará primero aplicar la sangría a la línea actual y, si la línea ya estaba sangrada, intentará completar el texto en el punto (véase <aclass="reference internal"href="27_EdDePrograms.html#id23"><spanclass="std std-ref">27.8 Completado de Nombres de Símbolos</span></a>). Si el valor es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> aplica sangría a la línea actual sólo si el punto está en el margen izquierdo o en la sangría de la línea; en caso contrario, inserta un carácter de tabulación.</p>
<p>Si <codeclass="docutils literal notranslate"><spanclass="pre">tab-always-indent</span></code> es completo, la opción de expandir o sangrar puede personalizarse aún más mediante la variable <codeclass="docutils literal notranslate"><spanclass="pre">tab-first-completion</span></code>. Por ejemplo, si esa variable es eol, sólo completa si el punto está al final de una línea. Vea <strong>Modo Específico de Sangría</strong> en el Manual de Referencia de Emacs Lisp, para más detalles.</p>
<p>El modo Electric Indent es un modo global menor que automáticamente indenta la línea después de cada <codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code> que escriba. Este modo está activado por defecto. Para activar este modo menor, escriba <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">electric-indent-mode</span></code>. Para activar este modo en un único búfer, use <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">electric-indent-local-mode</span></code>.</p>
<liclass="toctree-l3"><aclass="reference internal"href="#busqueda-de-documentacion-en-lenguajes-de-programacion">27.6.3. Búsqueda de Documentación en Lenguajes de Programación</a></li>
</ul>
</li>
<liclass="toctree-l2"><aclass="reference internal"href="#modo-secundario-presentacion-hideshow">27.7 Modo Secundario Presentación (Hideshow)</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#modo-menor-para-ocultamiento-hideshow">27.7 Modo Menor para Ocultamiento (Hideshow)</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#completado-de-nombres-de-simbolos">27.8 Completado de Nombres de Símbolos</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#palabras-en-mayusculas-y-minusculas">27.9 Palabras en Mayúsculas y Minúsculas</a></li>
<li><p>Búsqueda o desplazamiento sobre definiciones de nivel superior (véase <aclass="reference internal"href="#id2"><spanclass="std std-ref">27.2 Definiciones de Nivel Superior, o Defuns</span></a>).</p></li>
<li><p>Aplicación de las convenciones de sangría habituales del lenguaje (véase <aclass="reference internal"href="#id6"><spanclass="std std-ref">27.3 Indentación de Programas</span></a>).</p></li>
<li><p>Equilibrar paréntesis (ver <aclass="reference internal"href="#id9"><spanclass="std std-ref">27.4 Comandos para la Edición con Paréntesis</span></a>).</p></li>
<li><p>Insertar, eliminar o alinear comentarios (véase <aclass="reference internal"href="#id13"><spanclass="std std-ref">27.5. Manipulación de Comentarios</span></a>).</p></li>
<li><p>Aplicación de las convenciones de sangría habituales del lenguaje (véase <aclass="reference internal"href="#id7"><spanclass="std std-ref">27.3 Indentación de Programas</span></a>).</p></li>
<li><p>Equilibrar paréntesis (ver <aclass="reference internal"href="#id10"><spanclass="std std-ref">27.4 Comandos para la Edición con Paréntesis</span></a>).</p></li>
<li><p>Insertar, eliminar o alinear comentarios (véase <aclass="reference internal"href="#id14"><spanclass="std std-ref">27.5. Manipulación de Comentarios</span></a>).</p></li>
<li><p>Resaltar la sintaxis del programa (véase <aclass="reference internal"href="15_ControlDisplay.html#id3"><spanclass="std std-ref">15.3 Desplazamiento Automático</span></a>).</p></li>
</ul>
</div></blockquote>
@ -217,7 +217,7 @@
<p>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.</p>
<p>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 <aclass="reference internal"href="49_PaqEmacsLisp.html#id1"><spanclass="std std-ref">49 Paquetes Emacs Lisp</span></a>); o puede contribuir con uno.</p>
<p>Si Emacs ha sido compilado con la librería <codeclass="docutils literal notranslate"><spanclass="pre">tree-sitter</span></code>, ofrece varios modos de edición opcionales basados en esa librería, que utilizan las capacidades de análisis incremental proporcionadas por <codeclass="docutils literal notranslate"><spanclass="pre">tree-sitter</span></code>. Estos modos tienen <codeclass="docutils literal notranslate"><spanclass="pre">-ts-</span></code> en sus nombres; por ejemplo <codeclass="docutils literal notranslate"><spanclass="pre">c-ts-mode</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">python-ts-mode</span></code>, etc.</p>
<p>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 <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>) actualiza la sangría de la línea actual (ver <aclass="reference internal"href="#id6"><spanclass="std std-ref">27.3 Indentación de Programas</span></a>). Además, <codeclass="docutils literal notranslate"><spanclass="pre">DEL</span></code> suele estar vinculado a <codeclass="docutils literal notranslate"><spanclass="pre">backward-delete-char-untabify</span></code>, 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.</p>
<p>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 <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>) actualiza la sangría de la línea actual (ver <aclass="reference internal"href="#id7"><spanclass="std std-ref">27.3 Indentación de Programas</span></a>). Además, <codeclass="docutils literal notranslate"><spanclass="pre">DEL</span></code> suele estar vinculado a <codeclass="docutils literal notranslate"><spanclass="pre">backward-delete-char-untabify</span></code>, 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.</p>
<p>Al entrar en un modo de lenguaje de programación se ejecutan las funciones personalizadas de Lisp especificadas en la variable de gancho <codeclass="docutils literal notranslate"><spanclass="pre">prog-mode-hook</span></code>, seguidas de las especificadas en el propio <em>gancho de modo</em> del propio modo (véase <aclass="reference internal"href="24_ModosMayores-Y-Menores.html#id2"><spanclass="std std-ref">24.1 Modos Mayores (o Principales)</span></a>). Por ejemplo, al entrar en modo C se ejecutan los ganchos <codeclass="docutils literal notranslate"><spanclass="pre">prog-mode-hook</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">c-mode-hook</span></code>. Ver <aclass="reference internal"href="50_Personlzc.html#id7"><spanclass="std std-ref">50.2.2 Ganchos (Hooks)</span></a>, para información sobre éstos.</p>
<p>Hay manuales separados disponibles para los modos para Ada (ver <aclass="reference external"href="https://elpa.gnu.org/packages/ada-mode.html#Top">Modo Ada</a>), C/C++/Objective C/Java/Corba IDL/Pike/AWK (ver CC Mode en CC Mode), Octave, VHDL, e IDLWAVE (ver <strong>IDLWAVE</strong> en en el Manual de IDLWAVE).</p>
</section>
@ -252,7 +252,7 @@
externos</em> en su lugar.</p>
</section>
<sectionid="imenu">
<h3>27.2.3 Imenu<aclass="headerlink"href="#imenu"title="Link to this heading"></a></h3>
<spanid="id5"></span><h3>27.2.3 Imenu<aclass="headerlink"href="#imenu"title="Link to this heading"></a></h3>
<p>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 <aclass="reference internal"href="29_ManyProgrsGrands.html#id13"><spanclass="std std-ref">29.4 Buscar Referencias de Identificador</span></a>, para una función más potente que trata varios archivos juntos).</p>
<p>Si teclea <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">g</kbd><kbdclass="kbd docutils literal notranslate">i</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-g</span><spanclass="pre">i</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">imenu</span></code>), 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.</p>
<p>Alternativamente, puede vincular el comando <codeclass="docutils literal notranslate"><spanclass="pre">imenu</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">imenu-add-menubar-index</span></code>. 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 <codeclass="docutils literal notranslate"><spanclass="pre">imenu-add-menubar-index</span></code> 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.</p>
@ -260,21 +260,21 @@ externos</em> en su lugar.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">imenu-auto-rescan</span></code> se desactivará en búferes mayores que <codeclass="docutils literal notranslate"><spanclass="pre">imenu-auto-rescan-maxout</span></code> en bytes, y la exploración se detendrá si tarda más de <codeclass="docutils literal notranslate"><spanclass="pre">imenu-max-index-time</span><spanclass="pre">segundos</span></code>.</p>
<p>Puede personalizar la forma en que se ordenan los menús configurando la variable <codeclass="docutils literal notranslate"><spanclass="pre">imenu-sort-function</span></code>. Por defecto, los nombres se ordenan según aparecen en el búfer; si desea una ordenamiento alfabético, use el símbolo <codeclass="docutils literal notranslate"><spanclass="pre">imenu--sort-by-name</span></code> como valor. También puede definir su propia función de comparación escribiendo código Lisp.</p>
<p>Si Eglot está activado para el proyecto del búfer actual (véase <aclass="reference internal"href="29_ManyProgrsGrands.html#id9"><spanclass="std std-ref">29.2 Trabajar con Proyectos</span></a>) 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 <strong>Características de Eglot</strong> en Eglot: El cliente LSP de Emacs.</p>
<p>Imenu proporciona la información para guiar el modo Which Function (ver <aclass="reference internal"href="#id5"><spanclass="std std-ref">27.2.4 Modo Qué función (Which Function Mode)</span></a>). El Speedbar también puede usarlo (ver <aclass="reference internal"href="22_MarcosPantallasGraf.html#id10"><spanclass="std std-ref">22.9 Marcos con Speedbar (con barra de control o barra rápida)</span></a>).</p>
<p>Imenu proporciona la información para guiar el modo Which Function (ver <aclass="reference internal"href="#id6"><spanclass="std std-ref">27.2.4 Modo Qué función (Which Function Mode)</span></a>). El Speedbar también puede usarlo (ver <aclass="reference internal"href="22_MarcosPantallasGraf.html#id10"><spanclass="std std-ref">22.9 Marcos con Speedbar (con barra de control o barra rápida)</span></a>).</p>
<spanid="id5"></span><h3>27.2.4 Modo Qué función (Which Function Mode)<aclass="headerlink"href="#modo-que-funcion-which-function-mode"title="Link to this heading"></a></h3>
<spanid="id6"></span><h3>27.2.4 Modo Qué función (Which Function Mode)<aclass="headerlink"href="#modo-que-funcion-which-function-mode"title="Link to this heading"></a></h3>
<p>El modo Which Function es un modo menor global (véase <aclass="reference internal"href="24_ModosMayores-Y-Menores.html#id5"><spanclass="std std-ref">24.2 Modos Menores</span></a>) 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.</p>
<p>Para activar o desactivar el modo Which Function, use el comando <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">which-function-mode</span></code>. 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 <codeclass="docutils literal notranslate"><spanclass="pre">which-func-modes</span></code> de <codeclass="docutils literal notranslate"><spanclass="pre">t</span></code> (que significa soportar todos los modos principales disponibles) a una lista de nombres de modos principales.</p>
</section>
</section>
<sectionid="indentacion-de-programas">
<spanid="id6"></span><h2>27.3 Indentación de Programas<aclass="headerlink"href="#indentacion-de-programas"title="Link to this heading"></a></h2>
<spanid="id7"></span><h2>27.3 Indentación de Programas<aclass="headerlink"href="#indentacion-de-programas"title="Link to this heading"></a></h2>
<p>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.</p>
<p>Ver <aclass="reference internal"href="25_Indentacion.html#id1"><spanclass="std std-ref">25 Indentación</span></a>, 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.</p>
<p>Emacs también proporciona un Lisp pretty-printer en el paquete <codeclass="docutils literal notranslate"><spanclass="pre">pp</span></code>, que reformatea objetos Lisp con una sangría de aspecto agradable. Vea <strong>pp</strong> en el Manual de Referencia de Emacs Lisp.</p>
<spanid="id7"></span><h3>27.3.1 Comandos Básicos de Indentación de Programas<aclass="headerlink"href="#comandos-basicos-de-indentacion-de-programas"title="Link to this heading"></a></h3>
<spanid="id8"></span><h3>27.3.1 Comandos Básicos de Indentación de Programas<aclass="headerlink"href="#comandos-basicos-de-indentacion-de-programas"title="Link to this heading"></a></h3>
<div><p>Ajusta la indentación de la línea actual (<codeclass="docutils literal notranslate"><spanclass="pre">indent-for-tab-command</span></code>).</p>
@ -328,7 +328,7 @@ cadenas.</p>
</div>
</section>
<sectionid="comandos-para-la-indentacion-en-c">
<spanid="id8"></span><h3>27.3.4 Comandos para la Indentación en C<aclass="headerlink"href="#comandos-para-la-indentacion-en-c"title="Link to this heading"></a></h3>
<spanid="id9"></span><h3>27.3.4 Comandos para la Indentación en C<aclass="headerlink"href="#comandos-para-la-indentacion-en-c"title="Link to this heading"></a></h3>
<p>Estas son las funciones especiales para la sangría en modo C y modos relacionados:</p>
<div><p>Reindenta cada línea de la expresión equilibrada (véase <aclass="reference internal"href="#id10"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>), también conocida como «sexp», que sigue al punto. En modo CC,
<div><p>Reindenta cada línea de la expresión equilibrada (véase <aclass="reference internal"href="#id11"><spanclass="std std-ref">27.4.1 Expresiones con Paréntesis Equilibrados</span></a>), también conocida como «sexp», que sigue al punto. En modo CC,
esto invoca <codeclass="docutils literal notranslate"><spanclass="pre">c-indent-exp</span></code>; en modo <codeclass="docutils literal notranslate"><spanclass="pre">c-ts</span></code> basado en tree-sitter esto invoca un <codeclass="docutils literal notranslate"><spanclass="pre">prog-indent-sexp</span></code> más general. Un argumento
prefijo inhibe los mensajes de advertencia sobre sintaxis no válida.</p>
</div></blockquote>
@ -381,13 +381,13 @@ se selecciona todo el búfer como región y luego se reindenta esa región.</p>
<spanid="id9"></span><h2>27.4 Comandos para la Edición con Paréntesis<aclass="headerlink"href="#comandos-para-la-edicion-con-parentesis"title="Link to this heading"></a></h2>
<spanid="id10"></span><h2>27.4 Comandos para la Edición con Paréntesis<aclass="headerlink"href="#comandos-para-la-edicion-con-parentesis"title="Link to this heading"></a></h2>
<p>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.</p>
<p>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 <strong>Tablas de Sintaxis</strong> 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.</p>
<p>Puede usar <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">check-parens</span></code> para encontrar cualquier paréntesis y comillas de cadena no balanceados en el búfer.</p>
<spanid="id10"></span><h3>27.4.1 Expresiones con Paréntesis Equilibrados<aclass="headerlink"href="#expresiones-con-parentesis-equilibrados"title="Link to this heading"></a></h3>
<p>Cada modo de lenguaje de programación tiene su propia definición de una <em>expresión equilibrada</em>. 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 <aclass="footnote-reference brackets"href="#id12" id="id11" role="doc-noteref"><spanclass="fn-bracket">[</span>14<spanclass="fn-bracket">]</span></a>).</p>
<spanid="id11"></span><h3>27.4.1 Expresiones con Paréntesis Equilibrados<aclass="headerlink"href="#expresiones-con-parentesis-equilibrados"title="Link to this heading"></a></h3>
<p>Cada modo de lenguaje de programación tiene su propia definición de una <em>expresión equilibrada</em>. 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 <aclass="footnote-reference brackets"href="#id13" id="id12" role="doc-noteref"><spanclass="fn-bracket">[</span>14<spanclass="fn-bracket">]</span></a>).</p>
<div><p>Avanza sobre una expresión equilibrada (<codeclass="docutils literal notranslate"><spanclass="pre">forward-sexp</span></code>).</p>
@ -419,8 +419,8 @@ se selecciona todo el búfer como región y luego se reindenta esa región.</p>
<p>Para operar sobre expresiones equilibradas con un comando que actúe sobre la región, escriba <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">SPACE</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-M-SPC</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">mark-sexp</span></code>). Esto establece la marca a la que se movería <codeclass="docutils literal notranslate"><spanclass="pre">C-M-f</span></code>. 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 <codeclass="docutils literal notranslate"><spanclass="pre">C-M-@</span></code> es equivalente a <codeclass="docutils literal notranslate"><spanclass="pre">C-M-SPC</span></code>. Consulte <aclass="reference internal"href="12_LaMarca-y-LaRegion.html#id5"><spanclass="std std-ref">12.2 Comandos para Marcar Objetos Textuales</span></a>, para obtener más información sobre éste y otros comandos afines.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">foo</span><spanclass="pre">+</span><spanclass="pre">bar</span></code> como una única expresión, aunque sea una expresión C; en su lugar, reconoce <codeclass="docutils literal notranslate"><spanclass="pre">foo</span></code> como una expresión y <codeclass="docutils literal notranslate"><spanclass="pre">bar</span></code> como otra, con el <codeclass="docutils literal notranslate"><spanclass="pre">+</span></code> como signo de puntuación entre ellas. Sin embargo, el modo C reconoce <codeclass="docutils literal notranslate"><spanclass="pre">(foo</span><spanclass="pre">+</span><spanclass="pre">bar)</span></code> como una única expresión, debido a los paréntesis.</p>
<p>La palabra «sexp» se usa para referirse a una expresión en Lisp.</p>
</aside>
</aside>
@ -505,7 +505,7 @@ decidir si se salta el delimitador de cierre.</p></li>
</section>
</section>
<sectionid="manipulacion-de-comentarios">
<spanid="id13"></span><h2>27.5. Manipulación de Comentarios<aclass="headerlink"href="#manipulacion-de-comentarios"title="Link to this heading"></a></h2>
<spanid="id14"></span><h2>27.5. Manipulación de Comentarios<aclass="headerlink"href="#manipulacion-de-comentarios"title="Link to this heading"></a></h2>
<p>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 <aclass="reference internal"href="17_CmdCorrecErrsTipogr.html#id6"><spanclass="std std-ref">17.4 Comprobar y Corregir la Ortografía</span></a>).</p>
<p>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 (<codeclass="docutils literal notranslate"><spanclass="pre">;;</span></code>) tienen sangría como si fueran líneas de código, mientras que los que empiezan con tres puntos y coma (<codeclass="docutils literal notranslate"><spanclass="pre">;;;</span></code>) 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 <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>) en una línea de comentario, el comentario se sangrará a la posición adecuada.</p>
<div><p>Como <codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code> seguido de la inserción y alineación de un comentario (<codeclass="docutils literal notranslate"><spanclass="pre">default-indent-new-line</span></code>). Véase <aclass="reference internal"href="#id15"><spanclass="std std-ref">27.5.2 Varias Líneas de Comentarios</span></a>.</p>
<div><p>Como <codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code> seguido de la inserción y alineación de un comentario (<codeclass="docutils literal notranslate"><spanclass="pre">default-indent-new-line</span></code>). Véase <aclass="reference internal"href="#id16"><spanclass="std std-ref">27.5.2 Varias Líneas de Comentarios</span></a>.</p>
@ -553,7 +553,7 @@ decidir si se salta el delimitador de cierre.</p></li>
<p>El comando para crear o alinear un comentario es <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">comment-dwim</span></code>). 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.</p>
<p>Cuando una región está activa (véase <aclass="reference internal"href="12_LaMarca-y-LaRegion.html#id1"><spanclass="std std-ref">12 La marca y la región</span></a>), <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> 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.</p>
<p>Si proporciona un argumento de prefijo a <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> 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 <em>n</em> añade <em>n</em> delimitadores, mientras que un argumento negativo <em>-n</em> elimina <em>n</em> delimitadores.</p>
<p>Si la región no está activa y no hay ningún comentario en la línea actual, <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> sangraría (ver <aclass="reference internal"href="#id7"><spanclass="std std-ref">27.3.1 Comandos Básicos de Indentación de Programas</span></a>). 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 <codeclass="docutils literal notranslate"><spanclass="pre">comment-column</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">comment-fill-column</span></code> (ver <aclass="reference internal"href="#id16"><spanclass="std std-ref">27.5.3 Opciones que Controlan los Comentarios</span></a>), 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.</p>
<p>Si la región no está activa y no hay ningún comentario en la línea actual, <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code> sangraría (ver <aclass="reference internal"href="#id8"><spanclass="std std-ref">27.3.1 Comandos Básicos de Indentación de Programas</span></a>). 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 <codeclass="docutils literal notranslate"><spanclass="pre">comment-column</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">comment-fill-column</span></code> (ver <aclass="reference internal"href="#id17"><spanclass="std std-ref">27.5.3 Opciones que Controlan los Comentarios</span></a>), 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.</p>
<p>También puede usar <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> para alinear un comentario existente. Si una línea ya contiene la cadena de inicio de comentario, <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> 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, <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> sigue siendo útil para desplazarse directamente al inicio del texto del comentario.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">C-;</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">comment-line)</span><spanclass="pre">comenta</span></code> o descomenta líneas completas. Cuando una región está activa (véase <aclass="reference internal"href="12_LaMarca-y-LaRegion.html#id1"><spanclass="std std-ref">12 La marca y la región</span></a>), <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">C-;</span></code> 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 <em>n</em>, actúa sobre <em>n</em> líneas empezando por la actual; con un argumento negativo <em>-n</em>, afecta a <em>n</em> 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.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">M-;</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">comment-dwim</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">C-y</span><spanclass="pre">y</span></code>, a continuación, <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> para realinear el comentario. Puede conseguir el mismo efecto que <codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">M-;</span></code> escribiendo <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><codeclass="docutils literal notranslate"><spanclass="pre">comment-kill</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">comment-kill</span></code>) (<codeclass="docutils literal notranslate"><spanclass="pre">comment-dwim</span></code> en realidad llama a <codeclass="docutils literal notranslate"><spanclass="pre">comment-kill</span></code> como subrutina cuando se le da un argumento prefijo). Si se invoca a <codeclass="docutils literal notranslate"><spanclass="pre">comment-dwim</span></code> con un argumento numérico de prefijo, como en <codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">n</span><spanclass="pre">M-;</span></code>, cuando no hay ninguna región activa, se le dice a <codeclass="docutils literal notranslate"><spanclass="pre">comment-kill</span></code> que elimine los comentarios de <em>n</em> líneas.</p>
@ -561,7 +561,7 @@ decidir si se salta el delimitador de cierre.</p></li>
<p>Para modos similares a C, puede configurar el efecto exacto de <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> estableciendo las variables <codeclass="docutils literal notranslate"><spanclass="pre">c-indent-comment-alist</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">c-indent-comments-syntactically-p</span></code>. Por ejemplo, en una línea que termina en una llave de cierre, <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> pone el comentario un espacio después de la llave en lugar de en la <codeclass="docutils literal notranslate"><spanclass="pre">comment-colums</span></code>. Para más detalles, consulte <strong>Comandos de Comentario</strong> en el Manual del Modo CC.</p>
</section>
<sectionid="varias-lineas-de-comentarios">
<spanid="id15"></span><h3>27.5.2 Varias Líneas de Comentarios<aclass="headerlink"href="#varias-lineas-de-comentarios"title="Link to this heading"></a></h3>
<spanid="id16"></span><h3>27.5.2 Varias Líneas de Comentarios<aclass="headerlink"href="#varias-lineas-de-comentarios"title="Link to this heading"></a></h3>
<p>Si está escribiendo un comentario y desea continuarlo en otra línea, escriba: <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">j</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code>) o (<codeclass="docutils literal notranslate"><spanclass="pre">C-M-j</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">default-indent-new-line</span></code>). Esto rompe la línea actual e inserta los delimitadores de comentario y la sangría necesarios para continuar el comentario.</p>
<p>Para lenguajes con delimitadores de comentario de cierre (por ejemplo, <codeclass="docutils literal notranslate"><spanclass="pre">*/</span></code> en C), el comportamiento exacto de <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code> depende del valor de la variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-multi-line</span></code>. Si el valor es <codeclass="docutils literal notranslate"><spanclass="pre">nulo</span></code>, 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.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code>.</p>
@ -569,18 +569,18 @@ decidir si se salta el delimitador de cierre.</p></li>
<p>Puede configurar el modo C para que cuando escriba una <codeclass="docutils literal notranslate"><spanclass="pre">/</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">comment-close-slash</span></code>. Vea <strong>Limpiezas</strong> en el Manual del Modo CC.</p>
<spanid="id16"></span><h3>27.5.3 Opciones que Controlan los Comentarios<aclass="headerlink"href="#opciones-que-controlan-los-comentarios"title="Link to this heading"></a></h3>
<p>Como se mencionó en <aclass="reference internal"href="#id14"><spanclass="std std-ref">27.5.1 Comandos de Comentario</span></a>, cuando el comando <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code> añade un comentario a una línea, intenta colocar el comentario entre las columnas especificadas por las variables locales del búfer <codeclass="docutils literal notranslate"><spanclass="pre">comment-column</span></code> (columna-comentario) y <codeclass="docutils literal notranslate"><spanclass="pre">comment-fill-column</span></code> (o si es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, entonces el valor de <codeclass="docutils literal notranslate"><spanclass="pre">fill-column</span></code>, ver <aclass="reference internal"href="26_ComandsLengsHuma.html#id11"><spanclass="std std-ref">26.6.2 Comandos de Relleno Explícito</span></a>). Puede establecer el valor local o el valor por defecto de estas variables locales del búfer de la forma habitual (consulte <aclass="reference internal"href="50_Personlzc.html#id8"><spanclass="std std-ref">50.2.3 Variables Locales</span></a>). Alternativamente, puede teclear <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><kbdclass="kbd docutils literal notranslate">;</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">comment-set-column</span></code>) para establecer el valor de <codeclass="docutils literal notranslate"><spanclass="pre">comment-column</span></code> en el búfer actual a la columna donde se encuentra actualmente el punto. <codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">C-x</span><spanclass="pre">;</span></code> establece la columna de comentario para que coincida con el último comentario antes del punto en el búfer, y luego hace un <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> para alinear el comentario de la línea actual bajo el anterior.</p>
<spanid="id17"></span><h3>27.5.3 Opciones que Controlan los Comentarios<aclass="headerlink"href="#opciones-que-controlan-los-comentarios"title="Link to this heading"></a></h3>
<p>Como se mencionó en <aclass="reference internal"href="#id15"><spanclass="std std-ref">27.5.1 Comandos de Comentario</span></a>, cuando el comando <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code> añade un comentario a una línea, intenta colocar el comentario entre las columnas especificadas por las variables locales del búfer <codeclass="docutils literal notranslate"><spanclass="pre">comment-column</span></code> (columna-comentario) y <codeclass="docutils literal notranslate"><spanclass="pre">comment-fill-column</span></code> (o si es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, entonces el valor de <codeclass="docutils literal notranslate"><spanclass="pre">fill-column</span></code>, ver <aclass="reference internal"href="26_ComandsLengsHuma.html#id11"><spanclass="std std-ref">26.6.2 Comandos de Relleno Explícito</span></a>). Puede establecer el valor local o el valor por defecto de estas variables locales del búfer de la forma habitual (consulte <aclass="reference internal"href="50_Personlzc.html#id8"><spanclass="std std-ref">50.2.3 Variables Locales</span></a>). Alternativamente, puede teclear <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><kbdclass="kbd docutils literal notranslate">;</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">comment-set-column</span></code>) para establecer el valor de <codeclass="docutils literal notranslate"><spanclass="pre">comment-column</span></code> en el búfer actual a la columna donde se encuentra actualmente el punto. <codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">C-x</span><spanclass="pre">;</span></code> establece la columna de comentario para que coincida con el último comentario antes del punto en el búfer, y luego hace un <codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> para alinear el comentario de la línea actual bajo el anterior.</p>
<p>Los comandos de comentario reconocen los comentarios basándose en la expresión regular que es el valor de la variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-start-skip</span></code>. 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 <codeclass="docutils literal notranslate"><spanclass="pre">/\\*+[</span><spanclass="pre">\t]*\|//+[</span><spanclass="pre">\t]*</span></code>, que coincide con asteriscos y espacios extra después del propio <codeclass="docutils literal notranslate"><spanclass="pre">/\*</span></code>, y acepta también comentarios estilo C++ (<codeclass="docutils literal notranslate"><spanclass="pre">//</span></code>). (Observe que <codeclass="docutils literal notranslate"><spanclass="pre">\\</span></code> es necesario en la sintaxis Lisp para incluir un <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code> en la cadena, que es necesario para negar a la primera estrella su significado especial en la sintaxis expreg. Véase <aclass="reference internal"href="16_BusqReemp.html#id14"><spanclass="std std-ref">16.7 Barra Invertida en Expresiones Regulares</span></a>).</p>
<p>Cuando un comando comment crea un nuevo comentario, inserta el valor de <codeclass="docutils literal notranslate"><spanclass="pre">comment-start</span></code> como delimitador de apertura del comentario. También inserta el valor de <codeclass="docutils literal notranslate"><spanclass="pre">comment-end</span></code> después del punto, como delimitador de cierre del comentario. Por ejemplo, en modo Lisp, <codeclass="docutils literal notranslate"><spanclass="pre">comment-start</span></code> es <codeclass="docutils literal notranslate"><spanclass="pre">";"</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">comment-end</span></code> es <codeclass="docutils literal notranslate"><spanclass="pre">""</span></code> (la cadena vacía). En modo C, <codeclass="docutils literal notranslate"><spanclass="pre">comment-start</span></code> es <codeclass="docutils literal notranslate"><spanclass="pre">"/*</span><spanclass="pre">"</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">comment-end</span></code> es <codeclass="docutils literal notranslate"><spanclass="pre">"</span><spanclass="pre">*/"</span></code>.</p>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-padding</span></code> 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, <codeclass="docutils literal notranslate"><spanclass="pre">"</span><spanclass="pre">"</span></code>, especifica un único espacio. Alternativamente, el valor puede ser un número, que especifica ese número de espacios, o <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, que significa ningún espacio.</p>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-multi-line</span></code> controla cómo <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code> y el modo Auto Fill continúan los comentarios en múltiples líneas. Véase <aclass="reference internal"href="#id15"><spanclass="std std-ref">27.5.2 Varias Líneas de Comentarios</span></a>.</p>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-multi-line</span></code> controla cómo <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code> y el modo Auto Fill continúan los comentarios en múltiples líneas. Véase <aclass="reference internal"href="#id16"><spanclass="std std-ref">27.5.2 Varias Líneas de Comentarios</span></a>.</p>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">comment-indent-function</span></code> 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.</p>
<p>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.</p>
</section>
</section>
<sectionid="busqueda-de-documentacion">
<spanid="id17"></span><h2>27.6 Búsqueda de Documentación<aclass="headerlink"href="#busqueda-de-documentacion"title="Link to this heading"></a></h2>
<spanid="id18"></span><h2>27.6 Búsqueda de Documentación<aclass="headerlink"href="#busqueda-de-documentacion"title="Link to this heading"></a></h2>
<p>Emacs proporciona varias características que puede usar para buscar la documentación de funciones, variables y comandos que planea usar en su programa.</p>
<sectionid="busqueda-de-documentacion-en-info">
<h3>27.6.1 Búsqueda de Documentación en Info<aclass="headerlink"href="#busqueda-de-documentacion-en-info"title="Link to this heading"></a></h3>
@ -601,9 +601,9 @@ decidir si se salta el delimitador de cierre.</p></li>
<p>Para más información sobre cómo configurar y usar <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">woman</span></code>, vea el manual <strong>WoMan Info</strong>, que se distribuye con Emacs.</p>
<spanid="id18"></span><h3>27.6.3. Búsqueda de Documentación en Lenguajes de Programación<aclass="headerlink"href="#busqueda-de-documentacion-en-lenguajes-de-programacion"title="Link to this heading"></a></h3>
<spanid="id19"></span><h3>27.6.3. Búsqueda de Documentación en Lenguajes de Programación<aclass="headerlink"href="#busqueda-de-documentacion-en-lenguajes-de-programacion"title="Link to this heading"></a></h3>
<p>Cuando edite código Emacs Lisp, puede usar los comandos <codeclass="docutils literal notranslate"><spanclass="pre">C-h</span><spanclass="pre">f</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">describe-function</span></code>) y <codeclass="docutils literal notranslate"><spanclass="pre">C-h</span><spanclass="pre">v</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">describe-variable</span></code>) para ver la documentación incorporada para las funciones y variables Lisp que quiera usar. Consulte <aclass="reference internal"href="11_Ayuda.html#id3"><spanclass="std std-ref">11.3 Ayuda por Comando o Nombre de Variable</span></a>.</p>
<p>ElDoc <aclass="footnote-reference brackets"href="#id20" id="id19" role="doc-noteref"><spanclass="fn-bracket">[</span>15<spanclass="fn-bracket">]</span></a> 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.</p>
<p>ElDoc <aclass="footnote-reference brackets"href="#id21" id="id20" role="doc-noteref"><spanclass="fn-bracket">[</span>15<spanclass="fn-bracket">]</span></a> 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.</p>
<p>Para activar el modo ElDoc, escriba <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><codeclass="docutils literal notranslate"><spanclass="pre">eldoc-mode</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">eldoc-mode</span></code>)`. 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 <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">global-eldoc-mode</span></code> para desactivarlo globalmente.</p>
<p>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 <strong>Características de Eglot</strong> 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 <strong>Modo Resumen</strong> Inactivo en el Manual de Semantic); y Flymake, que usa ElDoc para mostrar diagnósticos en el punto (ver <strong>Encontrando Diagnósticos</strong> en el manual GNU Flymake).</p>
<p>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.</p>
@ -661,15 +661,15 @@ modo principal del búfer actual. Estas funciones actúan como una colección de
funciones de búsqueda de documentación con ElDoc añadiendo sus funciones al valor local del búfer de esta variable.</p>
<spanid="id21"></span><h2>27.7 Modo Secundario Presentación (Hideshow)<aclass="headerlink"href="#modo-secundario-presentacion-hideshow" title="Link to this heading"></a></h2>
<spanid="id22"></span><h2>27.7 Modo Menor para Ocultamiento (Hideshow)<aclass="headerlink"href="#modo-menor-para-ocultamiento-hideshow" title="Link to this heading"></a></h2>
<p>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 <em>bloques</em>. Escriba <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><codeclass="docutils literal notranslate"><spanclass="pre">hs-minor-mode</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">hs-minor-mode</span></code>) para activar este modo menor (ver <aclass="reference internal"href="24_ModosMayores-Y-Menores.html#id5"><spanclass="std std-ref">24.2 Modos Menores</span></a>).</p>
<p>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.</p>
<p>El modo Hideshow proporciona los siguientes comandos:</p>
<spanid="id22"></span><h2>27.8 Completado de Nombres de Símbolos<aclass="headerlink"href="#completado-de-nombres-de-simbolos"title="Link to this heading"></a></h2>
<spanid="id23"></span><h2>27.8 Completado de Nombres de Símbolos<aclass="headerlink"href="#completado-de-nombres-de-simbolos"title="Link to this heading"></a></h2>
<p>El completado se hace normalmente en el minibúfer (ver <aclass="reference internal"href="09_ElMinibufer.html#id4"><spanclass="std std-ref">9.4 Completado</span></a>), pero también puede completar nombres de símbolos en búferes Emacs ordinarios.</p>
<p>En la mayoría de los modos de lenguaje de programación, <codeclass="docutils literal notranslate"><spanclass="pre">C-M-i</span></code> (o <codeclass="docutils literal notranslate"><spanclass="pre">M-TAB</span></code><aclass="footnote-reference brackets"href="#id24" id="id23" role="doc-noteref"><spanclass="fn-bracket">[</span>16<spanclass="fn-bracket">]</span></a>) invoca el comando <codeclass="docutils literal notranslate"><spanclass="pre">completion-at-point</span></code>, 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:</p>
<p>En la mayoría de los modos de lenguaje de programación, <codeclass="docutils literal notranslate"><spanclass="pre">C-M-i</span></code> (o <codeclass="docutils literal notranslate"><spanclass="pre">M-TAB</span></code><aclass="footnote-reference brackets"href="#id25" id="id24" role="doc-noteref"><spanclass="fn-bracket">[</span>16<spanclass="fn-bracket">]</span></a>) invoca el comando <codeclass="docutils literal notranslate"><spanclass="pre">completion-at-point</span></code>, 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:</p>
<p>Si Eglot está activado para el proyecto del búfer actual (véase <aclass="reference internal"href="29_ManyProgrsGrands.html#id9"><spanclass="std std-ref">29.2 Trabajar con Proyectos</span></a>) 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 <strong>Características de Eglot</strong> en Eglot: El cliente LSP de Emacs.</p>
<p>Si el modo Semántico está habilitado (ver <aclass="reference internal"href="#id26"><spanclass="std std-ref">27.10 Semántica</span></a>), el comando intenta usar los datos del analizador semántico para completar.</p>
<p>Si el modo Semántico está habilitado (ver <aclass="reference internal"href="#id27"><spanclass="std std-ref">27.10 Semántica</span></a>), el comando intenta usar los datos del analizador semántico para completar.</p>
<p>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 <aclass="reference internal"href="29_ManyProgrsGrands.html#id18"><spanclass="std std-ref">29.4.2 Tablas de Etiquetas</span></a>); necesita visitar la tabla de etiquetas con <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">visit-tags-table</span></code> para que funcione.</p>
<p>En modo Emacs Lisp, el comando usa los nombres de función, variable o propiedad definidos en la sesión Emacs actual.</p>
<p>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 <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">↓</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-DOWN</span></code>) y <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">↑</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-UP</span></code>) para navegar a través de los completados mostrados en el búfer de completados sin dejar el búfer original, y la tecla <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">RETURN</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-RET</span></code>) para insertar el completado actualmente resaltado en el búfer. Véase <aclass="reference internal"href="09_ElMinibufer.html#id4"><spanclass="std std-ref">9.4 Completado</span></a>.</p>
<p>En el modo Texto (Text mode) y modos relacionados, <codeclass="docutils literal notranslate"><spanclass="pre">M-TAB</span></code> completa las palabras basándose en el diccionario del corrector ortográfico. Véase <aclass="reference internal"href="17_CmdCorrecErrsTipogr.html#id6"><spanclass="std std-ref">17.4 Comprobar y Corregir la Ortografía</span></a>.</p>
<p>En las pantallas gráficas, la tecla <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">M-TAB</span></code>) suele estar reservada por el gestor de ventanas para cambiar de ventana gráfica, por lo que deberá teclear <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">i</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-M-i</span></code>) o <kbdclass="kbd docutils literal notranslate">ESC</kbd><kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">ESC</span><spanclass="pre">TAB</span></code>) en su lugar.</p>
</aside>
</aside>
</section>
<sectionid="palabras-en-mayusculas-y-minusculas">
<spanid="id25"></span><h2>27.9 Palabras en Mayúsculas y Minúsculas<aclass="headerlink"href="#palabras-en-mayusculas-y-minusculas"title="Link to this heading"></a></h2>
<spanid="id26"></span><h2>27.9 Palabras en Mayúsculas y Minúsculas<aclass="headerlink"href="#palabras-en-mayusculas-y-minusculas"title="Link to this heading"></a></h2>
<p>Algunos estilos de programación usan símbolos mixtos (o «CamelCase») como <codeclass="docutils literal notranslate"><spanclass="pre">unReadableSymbol</span></code>. (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.</p>
<p>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.</p>
<p>Para activar este modo, escriba <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><codeclass="docutils literal notranslate"><spanclass="pre">glasses-mode</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">glasses-mode</span></code>) (véase <aclass="reference internal"href="24_ModosMayores-Y-Menores.html#id5"><spanclass="std std-ref">24.2 Modos Menores</span></a>). Cuando el modo Visor está activado, aparece el indicador de modo menor <codeclass="docutils literal notranslate"><spanclass="pre">o^o</span></code> en la línea de modo. Para obtener más información sobre el modo Glasses, escriba <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">h</kbd><kbdclass="kbd docutils literal notranslate">P</kbd><codeclass="docutils literal notranslate"><spanclass="pre">glasses</span></code><kbdclass="kbd docutils literal notranslate">RETURN</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-h</span><spanclass="pre">P</span><spanclass="pre">glasses</span><spanclass="pre">RET</span></code>).</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">StudlyCapsIdentifiers</span></code> como límites de palabra. Cuando este modo está activado, el indicador de modo menor <codeclass="docutils literal notranslate"><spanclass="pre">,</span></code> aparece en la línea de modo. Véase también el modo similar superpalabra (<codeclass="docutils literal notranslate"><spanclass="pre">superword-mode</span></code>) (véase <aclass="reference internal"href="#id29"><spanclass="std std-ref">27.11 Otras Funciones Útiles para Editar Programas</span></a>).</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">StudlyCapsIdentifiers</span></code> como límites de palabra. Cuando este modo está activado, el indicador de modo menor <codeclass="docutils literal notranslate"><spanclass="pre">,</span></code> aparece en la línea de modo. Véase también el modo similar superpalabra (<codeclass="docutils literal notranslate"><spanclass="pre">superword-mode</span></code>) (véase <aclass="reference internal"href="#id30"><spanclass="std std-ref">27.11 Otras Funciones Útiles para Editar Programas</span></a>).</p>
</section>
<sectionid="semantica">
<spanid="id26"></span><h2>27.10 Semántica<aclass="headerlink"href="#semantica"title="Link to this heading"></a></h2>
<spanid="id27"></span><h2>27.10 Semántica<aclass="headerlink"href="#semantica"title="Link to this heading"></a></h2>
<p>Semantic es un paquete que proporciona comandos de edición conscientes del lenguaje y basados en <em>analizadores de código fuente</em> (<codeclass="docutils literal notranslate"><spanclass="pre">source</span><spanclass="pre">code</span><spanclass="pre">parser</span></code>). Esta sección proporciona una breve descripción de Semantic; para más detalles, véase <strong>Semantic</strong> en la Guía de Semantic.</p>
<p>La mayoría de las funciones de Emacs que tienen en cuenta el lenguaje, como el modo de bloqueo de fuentes (véase <aclass="reference internal"href="15_ControlDisplay.html#id3"><spanclass="std std-ref">15.3 Desplazamiento Automático</span></a>), se basan en reglas empíricas <aclass="footnote-reference brackets"href="#id28" id="id27" role="doc-noteref"><spanclass="fn-bracket">[</span>17<spanclass="fn-bracket">]</span></a> 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.</p>
<p>La mayoría de las funciones de Emacs que tienen en cuenta el lenguaje, como el modo de bloqueo de fuentes (véase <aclass="reference internal"href="15_ControlDisplay.html#id3"><spanclass="std std-ref">15.3 Desplazamiento Automático</span></a>), se basan en reglas empíricas <aclass="footnote-reference brackets"href="#id29" id="id28" role="doc-noteref"><spanclass="fn-bracket">[</span>17<spanclass="fn-bracket">]</span></a> 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.</p>
<p>Para empezar a usar Semantic, escriba <kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">x</kbd><codeclass="docutils literal notranslate"><spanclass="pre">semantic-mode</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">semantic-mode</span></code>) o haga clic en la opción de menú denominada <codeclass="docutils literal notranslate"><spanclass="pre">Source</span><spanclass="pre">Code</span><spanclass="pre">Parsers</span><spanclass="pre">(Semantic)</span></code> en el menú <codeclass="docutils literal notranslate"><spanclass="pre">Tools</span></code> (Herramientas). Esto activa el modo Semántico, un modo global menor.</p>
<p>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:</p>
<p>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 <strong>Semantic</strong> en la Guía de Semantic, para más detalles.</p>
<spanid="id29"></span><h2>27.11 Otras Funciones Útiles para Editar Programas<aclass="headerlink"href="#otras-funciones-utiles-para-editar-programas"title="Link to this heading"></a></h2>
<spanid="id30"></span><h2>27.11 Otras Funciones Útiles para Editar Programas<aclass="headerlink"href="#otras-funciones-utiles-para-editar-programas"title="Link to this heading"></a></h2>
<p>Algunos comandos de Emacs que no están diseñados específicamente para editar programas son útiles para ello.</p>
<p>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 <aclass="reference internal"href="26_ComandsLengsHuma.html#id2"><spanclass="std std-ref">26.1 Palabras</span></a>), mientras que las sentencias se pueden encontrar en cadenas y comentarios (ver <aclass="reference internal"href="26_ComandsLengsHuma.html#id3"><spanclass="std std-ref">26.2 Frases (u oraciones)</span></a>). 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 <aclass="reference internal"href="26_ComandsLengsHuma.html#id4"><spanclass="std std-ref">26.3 Párrafos</span></a>). 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.</p>
<p>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, <codeclass="docutils literal notranslate"><spanclass="pre">esto_es_un_símbolo</span></code>) como palabras. Cuando el modo Superpalabra está activado, el indicador de modo menor <codeclass="docutils literal notranslate"><spanclass="pre">²</span></code> aparece en la línea de modo. Véase también el modo similar de subpalabra (<codeclass="docutils literal notranslate"><spanclass="pre">subword-mode</span></code>) (véase <aclass="reference internal"href="#id25"><spanclass="std std-ref">27.9 Palabras en Mayúsculas y Minúsculas</span></a>).</p>
<p>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, <codeclass="docutils literal notranslate"><spanclass="pre">esto_es_un_símbolo</span></code>) como palabras. Cuando el modo Superpalabra está activado, el indicador de modo menor <codeclass="docutils literal notranslate"><spanclass="pre">²</span></code> aparece en la línea de modo. Véase también el modo similar de subpalabra (<codeclass="docutils literal notranslate"><spanclass="pre">subword-mode</span></code>) (véase <aclass="reference internal"href="#id26"><spanclass="std std-ref">27.9 Palabras en Mayúsculas y Minúsculas</span></a>).</p>
<p>El modo Diseño Eléctrico (Electric Layout) (<cite>M-x electric-layout-mode`</cite>) es un modo menor global que inserta automáticamente nuevas líneas cuando se escriben ciertos caracteres; por ejemplo, <codeclass="docutils literal notranslate"><spanclass="pre">{</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">}</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">;</span></code> en el modo Javascript.</p>
<p>Aparte del modo Presentación (mode Hideshow) (ver <aclass="reference internal"href="#id21"><spanclass="std std-ref">27.7 Modo Secundario Presentación (Hideshow)</span></a>), otra forma de mostrar selectivamente partes de un programa es usar la función de visualización selectiva (ver <aclass="reference internal"href="15_ControlDisplay.html#id18"><spanclass="std std-ref">15.18 Visualización Selectiva</span></a>). Los modos de programación también suelen soportar el modo menor Esquema (véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id16"><spanclass="std std-ref">26.9 Modo Esquema (mode Outilne)</span></a>), que puede usarse con el paquete Plegado (véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id21"><spanclass="std std-ref">26.9.6 Edición de Plegado</span></a>).</p>
<p>Aparte del modo Presentación (mode Hideshow) (ver <aclass="reference internal"href="#id22"><spanclass="std std-ref">27.7 Modo Menor para Ocultamiento (Hideshow)</span></a>), otra forma de mostrar selectivamente partes de un programa es usar la función de visualización selectiva (ver <aclass="reference internal"href="15_ControlDisplay.html#id18"><spanclass="std std-ref">15.18 Visualización Selectiva</span></a>). Los modos de programación también suelen soportar el modo menor Esquema (véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id16"><spanclass="std std-ref">26.9 Modo Esquema (mode Outilne)</span></a>), que puede usarse con el paquete Plegado (véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id21"><spanclass="std std-ref">26.9.6 Edición de Plegado</span></a>).</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">lambda</span></code> por el carácter lambda griego <codeclass="docutils literal notranslate"><spanclass="pre">λ</span></code>. En un búfer TeX, sustituirá <codeclass="docutils literal notranslate"><spanclass="pre">\alpha</span></code> … <codeclass="docutils literal notranslate"><spanclass="pre">\omega</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">prettify-symbols-alist</span></code>. Una personalización más elaborada está disponible mediante la personalización de <codeclass="docutils literal notranslate"><spanclass="pre">prettify-symbols-compose-predicate</span></code> si su valor por defecto <codeclass="docutils literal notranslate"><spanclass="pre">prettify-symbols-default-compose-p</span></code> no es apropiado. También existe una versión global, <codeclass="docutils literal notranslate"><spanclass="pre">global-prettify-symbols-mode</span></code>, que activa el modo en todos los búferes que lo soportan.</p>
<p>El símbolo en el punto puede mostrarse en su forma original. Esto se controla mediante la variable <codeclass="docutils literal notranslate"><spanclass="pre">prettify-symbols-unprettify-at-point</span></code>: si no es nula, la forma original del símbolo en el punto se restaurará mientras el punto esté en él.</p>
</section>
@ -831,211 +831,257 @@ cuenta de repetición. Con un argumento negativo, se mueve hacia atrás.</p>
<blockquote>
<div><p>Mueve el punto al principio de la sentencia C más interna (<codeclass="docutils literal notranslate"><spanclass="pre">c-beginning-of-statement</span></code>). Si el punto ya está al principio de una
sentencia, se mueve al principio de la sentencia precedente. Con el argumento prefijo <em>n</em>, retrocede <em>n</em> - 1 sentencias.</p>
<p>En comentarios o en cadenas que abarcan más de una línea, este comando se mueve por sentencias en lugar de por sentencias.</p>
<p>En comentarios o en cadenas que abarcan más de una línea, este comando se mueve por oraciones en lugar de por sentencias.</p>
<div><p>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
<div><p>Mueve el punto al final del enunciado o frase C más interior; como <codeclass="docutils literal notranslate"><spanclass="pre">M-a</span></code> excepto que se mueve en la otra dirección
<h3>27.12.2 Caracteres C Eléctricos<aclass="headerlink"href="#caracteres-c-electricos"title="Link to this heading"></a></h3>
<p>En modo C y modos relacionados, ciertos caracteres de impresión son eléctricos, además de insertarse a sí mismos, también reentintan la línea actual, y opcionalmente también insertan nuevas líneas. Los caracteres eléctricos son {, }, :, #, ;, ,, <, >, /, <ahref="#id30"><spanclass="problematic"id="id31">*</span></a>, (, y ).</p>
<p>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.</p>
<dlclass="simple">
<dt>C-c C-l</dt><dd><p>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.</p>
</dd>
</dl>
<p>Los caracteres eléctricos insertan nuevas líneas sólo cuando, además del estado eléctrico, está activada la función de 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:</p>
<dlclass="simple">
<dt>C-c C-a</dt><dd><p>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.</p>
</dd>
</dl>
<p>Normalmente el estilo Modo CC configura las circunstancias exactas en las que Emacs inserta auto-newlines. También puede configurar esto directamente. Vea Custom Auto-newlines en The CC Mode Manual.</p>
<p>En modo C y modos relacionados, ciertos caracteres de impresión son <em>eléctricos</em>, 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 <codeclass="docutils literal notranslate"><spanclass="pre">{</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">}</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">:</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">#</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">;</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">,</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre"><</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">></span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">/</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">*</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">(</span></code>, y <codeclass="docutils literal notranslate"><spanclass="pre">)</span></code>.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">C-c</span><spanclass="pre">C-l</span></code>; cuando está activada, <codeclass="docutils literal notranslate"><spanclass="pre">/cl</span></code> aparece en la línea de modo después del nombre del modo (donde <em>c</em>, si está presente, es <codeclass="docutils literal notranslate"><spanclass="pre">*</span></code> o <codeclass="docutils literal notranslate"><spanclass="pre">/</span></code>, dependiendo de si el estilo de comentario es bloque o línea). Consulte <strong>Modos Menores</strong> en el Manual del Modo CC, para más información sobre los indicadores de línea de modo en el Modo CC.</p>
<div><p>Alterna la acción eléctrica (<codeclass="docutils literal notranslate"><spanclass="pre">c-toggle-electric-state</span></code>). Con un argumento prefijo positivo, este comando activa la acción eléctrica,
con uno negativo la desactiva.</p>
</div></blockquote>
<p>Los caracteres eléctricos insertan nuevas líneas sólo cuando, además del estado eléctrico, está activada la función <codeclass="docutils literal notranslate"><spanclass="pre">auto-newline</span></code> (indicada por <codeclass="docutils literal notranslate"><spanclass="pre">/cla</span></code> en la línea de modo después del nombre del modo). Puede activar o desactivar esta función con el comando <codeclass="docutils literal notranslate"><spanclass="pre">C-c</span><spanclass="pre">C-a</span></code>:</p>
<div><p>Activa la función de <codeclass="docutils literal notranslate"><spanclass="pre">auto-newline</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">c-toggle-auto-newline</span></code>). Con un argumento prefijo, este comando activa la función de
<codeclass="docutils literal notranslate"><spanclass="pre">auto-newline</span></code> si el argumento es positivo, y la desactiva si es negativo.</p>
</div></blockquote>
<p>Normalmente el estilo Modo CC configura las circunstancias exactas en las que Emacs inserta <codeclass="docutils literal notranslate"><spanclass="pre">auto-newlines</span></code>. También puede configurar esto directamente. Vea <strong>Nuevas Líneas Automáticas Personalizadas</strong> en el Manual CC).</p>
<h3>27.12.3. Característica de Borrado Forzado en C<aclass="headerlink"href="#caracteristica-de-borrado-forzado-en-c"title="Link to this heading"></a></h3>
<p>Si quiere borrar un bloque entero de espacio en blanco en un punto, puede usar el borrado forzado (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.</p>
<p>C-c C-DEL
C-c DEL</p>
<p>Si quiere borrar un bloque entero de espacio en blanco en un punto, puede usar el <em>borrado a la fueraza</em> (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.</p>
<div><p>Elimina todo el bloque de espacios en blanco que precede al punto (c-hungry-delete-backwards).</p>
<div><p>Elimina todo el bloque de espacios en blanco que precede al punto (<codeclass="docutils literal notranslate"><spanclass="pre">c-hungry-delete-backwards</span></code>).</p>
<div><p>Borra todo el bloque de espacios en blanco después del punto (c-hungry-delete-forward).</p>
<div><p>Borra todo el bloque de espacios en blanco después del punto (<codeclass="docutils literal notranslate"><spanclass="pre">c-hungry-delete-forward</span></code>).</p>
</div></blockquote>
<p>Como alternativa a los comandos anteriores, puede activar el modo de borrado con hambre. 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.</p>
<dl class="simple">
<dt>M-x c-toggle-hungry-state</dt><dd><p>Activa la función de borrado por hambre (c-toggle-hungry-state). Con un argumento prefijo, este comando activa la función de borrado por hambre si el argumento es positivo, y la
desactiva si es negativo.</p>
</dd>
</dl>
<p>La variable c-hungry-delete-key controla si la función hungry-delete está activada.</p>
<p>Como alternativa a los comandos anteriores, puede activar el modo de borrado forzoso. Cuando esta función está activada (indicada por <codeclass="docutils literal notranslate"><spanclass="pre">h</span></code> después de <codeclass="docutils literal notranslate"><spanclass="pre">/</span></code> en la línea de modo después del nombre del modo), un solo <codeclass="docutils literal notranslate"><spanclass="pre">DEL</span></code> borra todos los espacios en blanco precedentes, no sólo un espacio, y un solo <codeclass="docutils literal notranslate"><spanclass="pre">C-d</span></code> (pero no <codeclass="docutils literal notranslate"><spanclass="pre">Delete</span></code> normal) borra todos los espacios en blanco siguientes.</p>
<div><p>Activa la función de borrado forzoso (<codeclass="docutils literal notranslate"><spanclass="pre">c-toggle-hungry-state</span></code>). Con un argumento prefijo, este comando activa dicha función si el
argumento es positivo, y la desactiva si es negativo.</p>
</div></blockquote>
<p>La variable <codeclass="docutils literal notranslate"><spanclass="pre">c-hungry-delete-key</span></code> controla si la función <codeclass="docutils literal notranslate"><spanclass="pre">hungry-delete</span></code> está activada.</p>
</section>
<sectionid="otros-comandos-para-el-modo-c">
<spanid="id32"></span><h3>27.12.4 Otros comandos para el Modo C<aclass="headerlink"href="#otros-comandos-para-el-modo-c"title="Link to this heading"></a></h3>
<dl>
<dt>M-x c-context-line-break</dt><dd><p>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).</p>
<p>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.</p>
<spanid="id31"></span><h3>27.12.4 Otros comandos para el Modo C<aclass="headerlink"href="#otros-comandos-para-el-modo-c"title="Link to this heading"></a></h3>
<div><p>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
<codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">newline</span></code>, nueva línea), en una línea de preprocesador C inserta adicionalmente un <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code> en el salto de línea, y dentro de
los comentarios es como <codeclass="docutils literal notranslate"><spanclass="pre">M-j</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">c-indent-new-comment-line</span></code>).</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">c-context-line-break</span></code> no está vinculado a una tecla por defecto, pero necesita una vinculación para ser útil. El siguiente código
lo vinculará a <codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code>. Usamos <codeclass="docutils literal notranslate"><spanclass="pre">c-initialization-hook</span></code> aquí para asegurarnos de que el mapa de teclado está cargado antes de
<div><p>Pone marca al final de la definición de una función, y pone punto al principio ( <codeclass="docutils literal notranslate"><spanclass="pre">c-mark-function</span></code>).</p>
</div></blockquote>
</dd>
<dt>C-M-h</dt><dd><p>Pone marca al final de la definición de una función, y pone punto al principio ( c-mark-function).</p>
</dd>
<dt>M-q</dt><dd><p>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.</p>
</dd>
<dt>C-c C-e</dt><dd><p>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.</p>
<p>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.</p>
</dd>
<dt>C-c C-</dt><dd><p>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.</p>
<p>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.</p>
</dd>
<dt>M-x cpp-highlight-buffer</dt><dd><p>Resalta partes del texto según sus condicionales de preprocesador. Este comando muestra otro búfer llamado <em>CPP Edit</em>, 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.</p>
</dd>
<dt>C-c C-s</dt><dd><p>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.</p>
<div><p>Rellena un párrafo, manejando comentarios en C y C++ (<codeclass="docutils literal notranslate"><spanclass="pre">c-fill-paragraph</span></code>). 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.</p>
<div><p>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 (<codeclass="docutils literal notranslate"><spanclass="pre">c-macro-expand</span></code>). 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.</p>
<p>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.</p>
<div><p>Inserta o alinea caracteres <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code> en los extremos de las líneas de la región (<codeclass="docutils literal notranslate"><spanclass="pre">c-backslash-region</span></code>). Esto es útil después de
escribir o editar una definición de macro C.</p>
<p>Si una línea ya termina en <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code>, este comando ajusta la cantidad de espacio en blanco antes de ella. Si no, inserta un nuevo <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code>.
Sin embargo, la última línea de la región se trata de forma especial; no se inserta ningún <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code> en esa línea, y cualquier <codeclass="docutils literal notranslate"><spanclass="pre">\</span></code> que
<div><p>Resalta partes del texto según sus condicionales de preprocesador. Este comando muestra otro búfer llamado <codeclass="docutils literal notranslate"><spanclass="pre">*CPP</span><spanclass="pre">Edit*</span></code>, 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 <codeclass="docutils literal notranslate"><spanclass="pre">[A]pply</span><spanclass="pre">these</span><spanclass="pre">settings</span></code> ([A]plique estos parámetros) (o vaya a ese búfer y escriba <codeclass="docutils literal notranslate"><spanclass="pre">a)</span></code> para volver a
<div><p>Muestra la información sintáctica de la línea fuente actual (<codeclass="docutils literal notranslate"><spanclass="pre">c-show-syntactic-information</span></code>). Esta información indica cómo se aplica
<div><p>El modo menor de CWarn resalta ciertas construcciones sospechosas de C y C++:</p>
<blockquote>
<div><ulclass="simple">
<li><p>Asignaciones dentro de expresiones.</p></li>
<li><p>Punto y coma inmediatamente después de “if”, “for”, y “while” (excepto después de una sentencia “do … while”);</p></li>
<li><p>Punto y coma inmediatamente después de <codeclass="docutils literal notranslate"><spanclass="pre">if</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">for</span></code>, y <codeclass="docutils literal notranslate"><spanclass="pre">while</span></code> (excepto después de una sentencia <codeclass="docutils literal notranslate"><spanclass="pre">do</span><spanclass="pre">...</span><spanclass="pre">while</span></code>);</p></li>
<li><p>Funciones C++ con parámetros de referencia.</p></li>
</ul>
</div></blockquote>
<p>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.</p>
<p>Puede activar el modo para un búfer con el comando <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">cwarn-mode</span></code>, o para todos los búferes adecuados con el comando <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span>
<spanclass="pre">global-cwarn-mode</span></code> o personalizando la variable <codeclass="docutils literal notranslate"><spanclass="pre">global-cwarn-mode</span></code>. También debe habilitar el modo Font Lock para que funcione.</p>
<div><p>El modo menor Hide-ifdef oculta el código seleccionado dentro de los bloques de preprocesador <codeclass="docutils literal notranslate"><spanclass="pre">#if</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">#ifdef</span></code>. Si cambia la
variable <codeclass="docutils literal notranslate"><spanclass="pre">hide-ifdef-shadow</span></code> a <codeclass="docutils literal notranslate"><spanclass="pre">t</span></code>, 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 <codeclass="docutils literal notranslate"><spanclass="pre">hide-ifdef-mode</span></code> para más información.</p>
<div><p>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 <codeclass="docutils literal notranslate"><spanclass="pre">ff-related-file-alist</span></code> especifica cómo calcular los nombres de
archivos relacionados.</p>
</div></blockquote>
<dlclass="simple">
<dt>M-x hide-ifdef-mode</dt><dd><p>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.</p>
</dd>
<dt>M-x ff-find-related-file</dt><dd><p>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.</p>
</dd>
</dl>
</section>
</section>
<sectionid="modo-asm">
<h2>27.13 Modo Asm<aclass="headerlink"href="#modo-asm"title="Link to this heading"></a></h2>
<p>El modo Asm es un modo principal para editar archivos de código ensamblador. Define estos comandos:</p>
<dlclass="simple">
<dt>TAB</dt><dd><p>tab-to-tab-stop.</p>
</dd>
<dt>C-j</dt><dd><p>Inserta una nueva línea y luego aplica indentación usando tabulador a tabulador.</p>
</dd>
</dl>
<dlclass="simple">
<dt>:</dt><dd><p>Introduzca dos puntos y, a continuación, elimine la sangría de antes de los dos puntos de la etiqueta anterior. A continuación, haga tabulador a tabulador.</p>
</dd>
</dl>
<dlclass="simple">
<dt>;</dt><dd><p>Inserta o alinea un comentario.</p>
<div><p>Inserta una nueva línea y luego aplica indentación usando <codeclass="docutils literal notranslate"><spanclass="pre">tab-to-tab-stop</span></code>.</p>
<p>La variable asm-comment-char especifica qué carácter inicia los comentarios en la sintaxis de ensamblador.</p>
</section>
<sectionid="modo-fortran">
<h2>27.14 Modo Fortran<aclass="headerlink"href="#modo-fortran"title="Link to this heading"></a></h2>
<p>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.</p>
<p>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 Fill, 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 Modo Hideshow minor) e Imenu (véase Imenu).</p>
<spanid="id32"></span><h2>27.14 Modo Fortran<aclass="headerlink"href="#modo-fortran"title="Link to this heading"></a></h2>
<p>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 (<codeclass="docutils literal notranslate"><spanclass="pre">f90-mode</span></code>). Emacs normalmente usa el modo Fortran para archivos con extensión <codeclass="docutils literal notranslate"><spanclass="pre">.f</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">.F</span></code> o <codeclass="docutils literal notranslate"><spanclass="pre">.for</span></code>, y el modo F90 para las extensiones <codeclass="docutils literal notranslate"><spanclass="pre">.f90</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">.f95</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">.f03</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">.f08</span></code>. Personalice <codeclass="docutils literal notranslate"><spanclass="pre">auto-mode-alist</span></code> 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.</p>
<p>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 <aclass="reference internal"href="#id22"><spanclass="std std-ref">27.7 Modo Menor para Ocultamiento (Hideshow)</span></a>) e Imenu (véase <aclass="reference internal"href="#id5"><spanclass="std std-ref">27.2.3 Imenu</span></a>).</p>
<p>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.</p>
<p>Use M-x fortran-mode para cambiar a este modo principal. Este comando ejecuta el hook fortran-mode-hook. Consulte Ganchos.</p>
<p>Use <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">fortran-mode</span></code> para cambiar a este modo principal. Este comando ejecuta el gancho <codeclass="docutils literal notranslate"><spanclass="pre">fortran-mode-hook</span></code>. Consulte <aclass="reference internal"href="50_Personlzc.html#id7"><spanclass="std std-ref">50.2.2 Ganchos (Hooks)</span></a>.</p>
<sectionid="comandos-de-movimie">
<h3>27.14.1 Comandos de Movimie<aclass="headerlink"href="#comandos-de-movimie"title="Link to this heading"></a></h3>
<p>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.</p>
<dlclass="simple">
<dt>C-c C-n</dt><dd><p>Se mueve al principio de la siguiente sentencia (fortran-next-statement/f90-next-statement).</p>
</dd>
<dt>C-c C-p</dt><dd><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.</p>
</dd>
<dt>C-c C-e</dt><dd><p>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.</p>
</dd>
<dt>C-c C-a</dt><dd><p>Mueve el punto hacia atrás hasta el bloque anterior (f90-previous-block). Es como f90-next-block, pero se mueve hacia atrás.</p>
</dd>
<dt>C-M-n</dt><dd><p>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.</p>
</dd>
<dt>C-M-p</dt><dd><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.</p>
</dd>
</dl>
<p>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.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-end-of-subprogram</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">fortran-beginning-of-subprogram</span></code>), el modo Fortran proporciona comandos especiales para moverse por sentencias y otras unidades de programa.</p>
<div><p>Se mueve al principio de la siguiente sentencia (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-next-statement</span></code>/<codeclass="docutils literal notranslate"><spanclass="pre">f90-next-statement</span></code>).</p>
<div><p>Se desplaza al principio de la sentencia anterior (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-previous-statement</span></code>/<codeclass="docutils literal notranslate"><spanclass="pre">f90-previous-statement</span></code>). Si no hay sentencia
anterior (es decir, si se llama desde la primera sentencia del búfer), se desplaza al principio del búfer.</p>
<div><p>Avanza el punto hasta el inicio del siguiente bloque de código, o hasta el final del actual, lo que ocurra primero
(<codeclass="docutils literal notranslate"><spanclass="pre">f90-next-block</span></code>). Un bloque de código es una subrutina, una sentencia <codeclass="docutils literal notranslate"><spanclass="pre">if-endif</span></code>, 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.</p>
<div><p>Mueve el punto hacia atrás hasta el bloque anterior (<codeclass="docutils literal notranslate"><spanclass="pre">f90-previous-block</span></code>). Es como <codeclass="docutils literal notranslate"><spanclass="pre">f90-next-block</span></code>, pero se mueve hacia atrás.</p>
<div><p>Se desplaza al final del bloque de código actual (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-end-of-block</span></code>/<codeclass="docutils literal notranslate"><spanclass="pre">f90-end-of-block</span></code>). 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.</p>
<div><p>Se mueve al principio del bloque de código actual (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-beginning-of-block</span></code>/<codeclass="docutils literal notranslate"><spanclass="pre">f90-beginning-of-block</span></code>). Es como
<codeclass="docutils literal notranslate"><spanclass="pre">fortran-end-of-block</span></code>, pero se mueve hacia atrás.</p>
</div></blockquote>
<p>Las órdenes <codeclass="docutils literal notranslate"><spanclass="pre">fortran-beginning-of-subprogram</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">fortran-end-of-subprogram</span></code> se desplazan al inicio o al final del subprograma actual, respectivamente. Las órdenes <codeclass="docutils literal notranslate"><spanclass="pre">fortran-mark-do</span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">fortran-mark-if</span><spanclass="pre">marcan</span></code> el final del bloque actual <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> o <codeclass="docutils literal notranslate"><spanclass="pre">if</span></code>, y desplazan el punto al principio.</p>
</section>
<sectionid="indentacion-en-fortran">
<h3>27.14.2. Indentación en Fortran<aclass="headerlink"href="#indentacion-en-fortran"title="Link to this heading"></a></h3>
<spanid="id33"></span><h3>27.14.2. Indentación en Fortran<aclass="headerlink"href="#indentacion-en-fortran"title="Link to this heading"></a></h3>
<p>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.</p>
<h4>27.14.2.1. Comandos Fortran de Indentado y Relleno<aclass="headerlink"href="#comandos-fortran-de-indentado-y-relleno"title="Link to this heading"></a></h4>
<dlclass="simple">
<dt>C-M-j</dt><dd><p>Rompe la línea actual en un punto y establece una línea de continuación (fortran-split-line).</p>
</dd>
<dt>M-^</dt><dd><p>Une esta línea a la anterior (fortran-join-line).</p>
</dd>
<dt>C-M-q</dt><dd><p>Indenta todas las líneas del subprograma en el que se encuentra ese punto (fortran-indent-subprogram).</p>
</dd>
<dt>M-q</dt><dd><p>Rellena un bloque de comentarios o una sentencia (usando fortran-fill-paragraph o fortran-fill-statement).</p>
</dd>
</dl>
<p>La tecla 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.</p>
<p>La tecla 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.</p>
<p>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.</p>
<p>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.</p>
<div><p>Rompe la línea actual en un punto y establece una línea de continuación (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-split-line</span></code>).</p>
<div><p>Indenta todas las líneas del subprograma en el que se encuentra ese punto (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-indent-subprogram</span></code>).</p>
<div><p>Rellena un bloque de comentarios o una sentencia (usando <codeclass="docutils literal notranslate"><spanclass="pre">fortran-fill-paragraph</span></code> o <codeclass="docutils literal notranslate"><spanclass="pre">fortran-fill-statement</span></code>).</p>
</div></blockquote>
<p>La combinación de teclas <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">q</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-M-q</span></code>) ejecuta <codeclass="docutils literal notranslate"><spanclass="pre">fortran-indent-subprogram</span></code>, una orden para volver a sangrar todas las líneas del subprograma Fortran (función o subrutina) que contiene el punto.</p>
<p>La combinación de teclas <kbdclass="kbd docutils literal notranslate">Ctrl</kbd>-<kbdclass="kbd docutils literal notranslate">Alt</kbd>-<kbdclass="kbd docutils literal notranslate">j</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">C-M-j</span></code>) ejecuta <codeclass="docutils literal notranslate"><spanclass="pre">fortran-split-line</span></code>, 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.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">M-^</span></code> o <codeclass="docutils literal notranslate"><spanclass="pre">C-c</span><spanclass="pre">C-d</span></code> ejecutan el comando <codeclass="docutils literal notranslate"><spanclass="pre">fortran-join-line</span></code>, que une una línea de continuación con la línea anterior, más o menos como la inversa de <codeclass="docutils literal notranslate"><spanclass="pre">fortran-split-line</span></code>. El punto debe estar en una línea de continuación cuando se invoque este comando.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">M-q</span></code> 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.</p>
</section>
<sectionid="lineas-de-continuacion">
<h4>27.14.2.2. Líneas de Continuación<aclass="headerlink"href="#lineas-de-continuacion"title="Link to this heading"></a></h4>
<p>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 Características Opcionales del Modo Línea). 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).</p>
<p>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.</p>
<p>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.</p>
<spanid="id34"></span><h4>27.14.2.2. Líneas de Continuación<aclass="headerlink"href="#lineas-de-continuacion"title="Link to this heading"></a></h4>
<p>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 <em>forma fija</em>. (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 <codeclass="docutils literal notranslate"><spanclass="pre">column-number-indicator-zero-based</span></code> para hacer que la visualización de la columna sea similar a Fortran; vea <aclass="reference internal"href="15_ControlDisplay.html#id19"><spanclass="std std-ref">15.19 Características Opcionales de la Línea de Modo</span></a>). La variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-continuation-string</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">0</span></code> es también una línea de continuación. Llamamos a este estilo de continuación <em>formato tabulador</em>. (Fortran 90 introdujo las líneas de continuación de forma libre).</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-tab-mode-default</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code> para la forma fija y no <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code> para el formato tab). <codeclass="docutils literal notranslate"><spanclass="pre">/t</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-tab-mode-string</span></code>) 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.</p>
<p>Si el texto de una línea comienza con el marcador de continuación de Fortran <codeclass="docutils literal notranslate"><spanclass="pre">$</span></code>, 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 <codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>, convierte la línea al estilo de continuación actual. Al dividir una sentencia Fortran con <codeclass="docutils literal notranslate"><spanclass="pre">C-M-j</span></code>, el marcador de continuación en la nueva línea se crea según el estilo de continuación.</p>
<p>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.</p>
</section>
<sectionid="numeros-de-linea">
<h4>27.14.2.3. Números de Línea<aclass="headerlink"href="#numeros-de-linea"title="Link to this heading"></a></h4>
<p>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 Características de Línea en Modo Opcional).</p>
<p>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.</p>
<p>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-número-de-línea en nil.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">column-number-indicator-zero-based</span></code> a <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code> puede cambiar esto, vea <aclass="reference internal"href="15_ControlDisplay.html#id19"><spanclass="std std-ref">15.19 Características Opcionales de la Línea de Modo</span></a>).</p>
<p>Los números de línea de cuatro dígitos o menos tienen normalmente una sangría de un espacio. La variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-line-number-indent</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-line-number-indent</span></code> tiene el valor 5, los números de línea se justifican a la derecha para terminar en la columna 4.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-electric-number-line</span></code> a <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>.</p>
</section>
<sectionid="convenciones-sintacticas">
<h4>27.14.2.4 Convenciones Sintácticas<aclass="headerlink"href="#convenciones-sintacticas"title="Link to this heading"></a></h4>
<p>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:</p>
<blockquote>
<div><ulclass="simple">
<li><p>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</p></li>
<div><ul>
<li><p>Dos bucles <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> anidados nunca comparten una sentencia <codeclass="docutils literal notranslate"><spanclass="pre">continue</span></code>. Las palabras clave de Fortran como <codeclass="docutils literal notranslate"><spanclass="pre">if</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">else</span></code>,
<codeclass="docutils literal notranslate"><spanclass="pre">then</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> y otras se escriben sin espacios en blanco ni saltos de línea.</p></li>
<li><p>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.</p>
<p>Construcciones como <codeclass="docutils literal notranslate"><spanclass="pre">else</span></code><codeclass="docutils literal notranslate"><spanclass="pre">if</span></code> o <codeclass="docutils literal notranslate"><spanclass="pre">end</span><spanclass="pre">do</span></code> 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.</p>
</li>
</ul>
<p>de línea.</p>
<ulclass="simple">
<li><p>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.</p></li>
</ul>
<p>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.</p>
</div></blockquote>
<p>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.</p>
</section>
@ -1043,25 +1089,28 @@ estar incompleto.</p>
<h4>27.14.2.5. Variables para el Indentado en Fortran<aclass="headerlink"href="#variables-para-el-indentado-en-fortran"title="Link to this heading"></a></h4>
<p>Varias variables adicionales controlan cómo funciona la sangría en Fortran:</p>
<dlclass="simple">
<dt>fortran-do-indent</dt><dd><p>Indentación extra dentro de cada nivel de la sentencia “do” (por defecto 3).</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-do-indent</span></code></dt><dd><p>Indentación extra dentro de cada nivel de la sentencia <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> (por defecto 3).</p>
</dd>
<dt>fortran-if-indent</dt><dd><p>Indentación extra dentro de cada nivel de sentencias “if”, “select case”, o “where” (por defecto 3).</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-if-indent</span></code></dt><dd><p>Indentación extra dentro de cada nivel de sentencias <codeclass="docutils literal notranslate"><spanclass="pre">if</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">select</span><spanclass="pre">case</span></code>, o <codeclass="docutils literal notranslate"><spanclass="pre">where</span></code> (por defecto 3).</p>
</dd>
<dt>fortran-structure-indent</dt><dd><p>Indentación extra dentro de cada nivel de sentencias “structure”, “union”, “map”, o “interface” (por defecto 3).</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-structure-indent</span></code></dt><dd><p>Indentación extra dentro de cada nivel de sentencias <codeclass="docutils literal notranslate"><spanclass="pre">structure</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">union</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">map</span></code>, o <codeclass="docutils literal notranslate"><spanclass="pre">interface</span></code> (por defecto 3).</p>
</dd>
<dt>fortran-continuation-indent</dt><dd><p>Sangría adicional para los cuerpos de las líneas de continuación (por defecto 5).</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-continuation-indent</span></code></dt><dd><p>Sangría adicional para los cuerpos de las líneas de continuación (por defecto 5).</p>
</dd>
<dt>fortran-check-all-num-for-matching-do</dt><dd><p>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).</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-check-all-num-for-matching-do</span></code></dt><dd><p>En Fortran 77, una sentencia <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> numerada es terminada por cualquier sentencia con un número de línea coincidente. Es común (pero
no obligatorio) usar una sentencia <codeclass="docutils literal notranslate"><spanclass="pre">continue</span></code> para este propósito. Si esta variable tiene un valor no nulo, la indentación de
cualquier sentencia numerada debe comprobar si hay una <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> que termine ahí. Si siempre termina las sentencias <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code> con una línea
<codeclass="docutils literal notranslate"><spanclass="pre">continue</span></code> (o si usa el más moderno <codeclass="docutils literal notranslate"><spanclass="pre">enddo</span></code>), entonces puede acelerar la indentación estableciendo esta variable a <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code> (por
defecto).</p>
</dd>
<dt>fortran-blink-matching-if</dt><dd><p>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.</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-blink-matching-if</span></code></dt><dd><p>Si es <codeclass="docutils literal notranslate"><spanclass="pre">t</span></code>, al indentar una sentencia <codeclass="docutils literal notranslate"><spanclass="pre">endif</span></code> (o <codeclass="docutils literal notranslate"><spanclass="pre">enddo</span></code>) el cursor se mueve momentáneamente a la sentencia <codeclass="docutils literal notranslate"><spanclass="pre">if</span></code> (o <codeclass="docutils literal notranslate"><spanclass="pre">do</span></code>)
correspondiente para mostrar dónde está. Por defecto es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>.</p>
</dd>
<dt>fortran-minimum-statement-indent-fixed</dt><dd><p>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.</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-minimum-statement-indent-fixed</span></code></dt><dd><p>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.</p>
</dd>
<dt>fortran-minimum-statement-indent-tab</dt><dd><p>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.</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fortran-minimum-statement-indent-tab</span></code></dt><dd><p>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.</p>
</dd>
</dl>
<p>La siguiente sección describe las variables que controlan la sangría de los comentarios.</p>
@ -1070,65 +1119,79 @@ predeterminado es 8.</p>
<sectionid="comentarios-en-fortran">
<h3>27.14.3. Comentarios en Fortran<aclass="headerlink"href="#comentarios-en-fortran"title="Link to this heading"></a></h3>
<p>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.</p>
<p>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.</p>
<dlclass="simple">
<dt>M-;</dt><dd><p>Permite alinear un comentario o insertar uno nuevo (comment-dwim).</p>
</dd>
<dt>C-x ;</dt><dd><p>Sólo se aplica a los comentarios “!” no estándar (comment-set-column).</p>
</dd>
<dt>C-c ;</dt><dd><p>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).</p>
</dd>
</dl>
<p>M-; en modo Fortran ejecuta el 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.</p>
<p>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.</p>
<p>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:</p>
<p>El modo Fortran también puede manejar la sintaxis de comentarios de Fortran 90, en la que los comentarios empiezan por <codeclass="docutils literal notranslate"><spanclass="pre">!</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-line-start</span></code> a <codeclass="docutils literal notranslate"><spanclass="pre">"!"</span></code>. Si usa un valor inusual, puede que necesite cambiar <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-line-start-skip</span></code>.</p>
<div><p>Permite alinear un comentario o insertar uno nuevo (<codeclass="docutils literal notranslate"><spanclass="pre">comment-dwim</span></code>).</p>
<div><p>Sólo se aplica a los comentarios <codeclass="docutils literal notranslate"><spanclass="pre">!</span></code> no estándar (<codeclass="docutils literal notranslate"><spanclass="pre">comment-set-column</span></code>).</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">M-;</span></code> en modo Fortran ejecuta el comando <codeclass="docutils literal notranslate"><spanclass="pre">comment-dwim</span></code> 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.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">!</span></code> 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.</p>
<p>Los comentarios <codeclass="docutils literal notranslate"><spanclass="pre">!</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-indent-style</span></code> a uno de estos valores:</p>
<dl>
<dt>fixed</dt><dd><p>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.</p>
<p>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.</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">fixed</span></code></dt><dd><p>Alinea el texto en una columna fija, que es la suma de <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-line-extra-indent</span></code> y la sangría mínima de la sentencia. Este
es el valor por defecto.</p>
<p>La sangría mínima es <codeclass="docutils literal notranslate"><spanclass="pre">fortran-minimum-statement-indent-tab</span></code> para el estilo de línea de continuación con formato tabulador y
<codeclass="docutils literal notranslate"><spanclass="pre">fortran-minimum-statement-indent-fixed</span></code> para el estilo de formulario fijo.</p>
</dd>
<dt>relative</dt><dd><p>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.</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">relative</span></code></dt><dd><p>Alinea el texto como si fuera una línea de código, pero con una columna adicional de sangría <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-line-extra-indent</span></code>.</p>
</dd>
<dt>nil</dt><dd><p>No mueve automáticamente el texto en los comentarios de línea completa.</p>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code></dt><dd><p>No mueve automáticamente el texto en los comentarios de línea completa.</p>
</dd>
</dl>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>Además, puede especificar el carácter que se usará para sangrar dentro de los comentarios de línea completa estableciendo la variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-indent-char</span></code> en la cadena de un solo carácter que desee usar.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-indent-style</span></code>. La variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-directive-re</span></code> 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.</p>
<p>El comando de comentario normal de Emacs <codeclass="docutils literal notranslate"><spanclass="pre">C-x</span><spanclass="pre">;</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">comment-set-column</span></code>) no ha sido redefinido. Si usa comentarios <codeclass="docutils literal notranslate"><spanclass="pre">!</span></code>, este comando puede usarse con ellos. De lo contrario, es inútil en modo Fortran.</p>
<p>El comando <codeclass="docutils literal notranslate"><spanclass="pre">C-c</span><spanclass="pre">;</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-region</span></code>) convierte todas las líneas de la región en comentarios insertando la cadena <codeclass="docutils literal notranslate"><spanclass="pre">c$$$</span></code> al principio de cada una. Con un argumento numérico, convierte la región de nuevo en código dinámico borrando <codeclass="docutils literal notranslate"><spanclass="pre">c$$$</span></code> del principio de cada línea. La cadena usada para estos comentarios puede controlarse estableciendo la variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-comment-region</span></code>. 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.</p>
</section>
<sectionid="relleno-automatico-en-modo-fortran">
<h3>27.14.4. Relleno Automático en Modo Fortran<aclass="headerlink"href="#relleno-automatico-en-modo-fortran"title="Link to this heading"></a></h3>
<p>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 Líneas de continuación). Esta división se produce cuando escribe SPC, RET o TAB, y también en los comandos de indentación de Fortran. Active Auto Fill en modo Fortran de la forma habitual. Véase Modo Auto Fill.</p>
<p>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.</p>
<p>Para activar el relleno automático en todos los búferes de Fortran, añada auto-fill-mode a fortran-mode-hook. Véase Ganchos.</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-continuation-string</span></code> (vea <aclass="reference internal"href="#id34"><spanclass="std std-ref">27.14.2.2. Líneas de Continuación</span></a>). Esta división se produce cuando escribe <kbdclass="kbd docutils literal notranslate">SPACE</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">SPC</span></code>), <kbdclass="kbd docutils literal notranslate">RETURN</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">RET</span></code>) o <kbdclass="kbd docutils literal notranslate">TAB</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">TAB</span></code>), y también en los comandos de indentación de Fortran. Active Auto Fill en modo Fortran de la forma habitual. Véase <aclass="reference internal"href="26_ComandsLengsHuma.html#id10"><spanclass="std std-ref">26.6.1 Modo de Relleno Automático (Auto Fill)</span></a>).</p>
<p>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 <codeclass="docutils literal notranslate"><spanclass="pre">fill-column</span></code>). Los delimitadores (además de los espacios en blanco) con los que Auto Fill puede romper son <codeclass="docutils literal notranslate"><spanclass="pre">+</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">-</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">/</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">*</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">=</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre"><</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">></span></code> y <codeclass="docutils literal notranslate"><spanclass="pre">,</span></code>. El salto de línea se produce después del delimitador si la variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-break-before-delimiters</span></code> es nula. En caso contrario (y por defecto), el salto va antes del delimitador.</p>
<p>Para activar el relleno automático en todos los búferes de Fortran, añada <codeclass="docutils literal notranslate"><spanclass="pre">auto-fill-mode</span></code> a <codeclass="docutils literal notranslate"><spanclass="pre">fortran-mode-hook</span></code>. Véase <aclass="reference internal"href="50_Personlzc.html#id7"><spanclass="std std-ref">50.2.2 Ganchos (Hooks)</span></a>.</p>
</section>
<sectionid="comprobacion-de-columnas-en-fortran">
<h3>27.14.5. Comprobación de Columnas en Fortran<aclass="headerlink"href="#comprobacion-de-columnas-en-fortran"title="Link to this heading"></a></h3>
<p>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 font-lock).</p>
<dlclass="simple">
<dt>C-c C-r</dt><dd><p>Muestra una regla de columnas momentáneamente sobre la línea actual (fortran-column-ruler).</p>
</dd>
<dt>C-c C-w</dt><dd><p>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.</p>
</dd>
<dt>C-u C-c C-w</dt><dd><p>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.</p>
</dd>
<dt>M-x fortran-strip-sequence-nos</dt><dd><p>Borra todo el texto de la columna fortran-longitud de línea y posteriores.</p>
</dd>
</dl>
<p>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.</p>
<p>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 Características de línea de modo opcional). 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.</p>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>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, <codeclass="docutils literal notranslate"><spanclass="pre">-ffixed-line-length-N</span></code> 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 <codeclass="docutils literal notranslate"><spanclass="pre">fortran-line-length</span></code> confundirán el bloqueo de fuentes (font-lock)).</p>
<div><p>Muestra una regla de columnas momentáneamente sobre la línea actual (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-column-ruler</span></code>).</p>
<div><p>Divide la ventana actual horizontalmente de forma temporal para que tenga columnas de longitud de línea fortran
(<codeclass="docutils literal notranslate"><spanclass="pre">fortran-window-create-momentarily</span></code>). Esto puede ayudarle a evitar hacer líneas más largas que el límite impuesto por su compilador de
<div><p>Divide la ventana actual horizontalmente para que tenga columnas de longitud de línea de fortran de ancho (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-window-create</span></code>). A
<div><p>Borra todo el texto de la columna <codeclass="docutils literal notranslate"><spanclass="pre">fortran-longitud</span></code> de línea y posteriores.</p>
</div></blockquote>
<p>El comando <codeclass="docutils literal notranslate"><spanclass="pre">C-c</span><spanclass="pre">C-r</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-column-ruler</span></code>) 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.</p>
<p>Tenga en cuenta que los números de columna cuentan desde cero, como siempre en GNU Emacs (pero personalizando <codeclass="docutils literal notranslate"><spanclass="pre">column-number-indicator-zero-based</span></code> puede cambiar la visualización de las columnas para que coincida con la de Fortran; vea <aclass="reference internal"href="15_ControlDisplay.html#id19"><spanclass="std std-ref">15.19 Características Opcionales de la Línea de Modo</span></a>). 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.</p>
<p>El texto usado para mostrar la regla de columna depende del valor de la variable <codeclass="docutils literal notranslate"><spanclass="pre">indent-tabs-mode</span></code>. Si <codeclass="docutils literal notranslate"><spanclass="pre">indent-tabs-mode</span></code> es <codeclass="docutils literal notranslate"><spanclass="pre">nil</span></code>, entonces se usa el valor de la variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-column-ruler-fixed</span></code> como regla de columna. En caso contrario, se muestra el valor de la variable <codeclass="docutils literal notranslate"><spanclass="pre">fortran-column-ruler-tab</span></code>. Cambiando estas variables, puede cambiar la visualización de la regla de columna.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">C-c</span><spanclass="pre">C-w</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">fortran-window-create-momentarily</span></code>) 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.</p>
<p>También puede dividir la ventana horizontalmente y continuar editando con la división en su lugar. Para usar esto, use <codeclass="docutils literal notranslate"><spanclass="pre">C-u</span><spanclass="pre">C-c</span><spanclass="pre">C-w</span></code> (<codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">fortran-window-create</span></code>). Editando en esta ventana puede ver inmediatamente cuando hace una línea demasiado ancha para ser Fortran correcto.</p>
<p>El comando <codeclass="docutils literal notranslate"><spanclass="pre">M-x</span><spanclass="pre">fortran-strip-sequence-nos</span></code> borra todo el texto de la columna <codeclass="docutils literal notranslate"><spanclass="pre">fortran-line-length</span></code> 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.</p>
<h3>27.14.6. Abreviaturas de Palabras Clave en Fortran<aclass="headerlink"href="#abreviaturas-de-palabras-clave-en-fortran"title="Link to this heading"></a></h3>
<p>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 Abreviaturas.</p>
<p>Las abreviaturas incorporadas son inusuales en un sentido: todas empiezan por punto y coma. Por ejemplo, una abreviatura incorporada en Fortran es “;c” para “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.</p>
<p>Escriba “;?” o “;C-h” para ver una lista de todas las abreviaturas de Fortran y lo que significan.</p>
<p>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 <aclass="reference internal"href="30_Abreviaturas.html#id1"><spanclass="std std-ref">30 Abreviaturas</span></a>.</p>
<p>Las abreviaturas incorporadas son inusuales en un sentido: todas empiezan por punto y coma. Por ejemplo, una abreviatura incorporada en Fortran es <codeclass="docutils literal notranslate"><spanclass="pre">;c</span></code> para <codeclass="docutils literal notranslate"><spanclass="pre">continue</span></code> (continuar). Si inserta <codeclass="docutils literal notranslate"><spanclass="pre">;c</span></code> y luego inserta un carácter de puntuación como un espacio o una nueva línea, la <codeclass="docutils literal notranslate"><spanclass="pre">;c</span></code> se expande automáticamente a <codeclass="docutils literal notranslate"><spanclass="pre">continue</span></code>, siempre que el modo Abbrev esté activado.</p>
<p>Escriba <kbdclass="kbd docutils literal notranslate">;</kbd><kbdclass="kbd docutils literal notranslate">?</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">;?</span></code>) o <kbdclass="kbd docutils literal notranslate">Ctrl</kbd><kbdclass="kbd docutils literal notranslate">h</kbd> (<codeclass="docutils literal notranslate"><spanclass="pre">;C-h</span></code>) para ver una lista de todas las abreviaturas de Fortran y lo que significan.</p>
@ -582,7 +582,7 @@ de la libertad del software.»</p>
<liclass="toctree-l3"><aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#busqueda-de-documentacion-en-lenguajes-de-programacion">27.6.3. Búsqueda de Documentación en Lenguajes de Programación</a></li>
</ul>
</li>
<liclass="toctree-l2"><aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#modo-secundario-presentacion-hideshow">27.7 Modo Secundario Presentación (Hideshow)</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#modo-menor-para-ocultamiento-hideshow">27.7 Modo Menor para Ocultamiento (Hideshow)</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#completado-de-nombres-de-simbolos">27.8 Completado de Nombres de Símbolos</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#palabras-en-mayusculas-y-minusculas">27.9 Palabras en Mayúsculas y Minúsculas</a></li>
<p>Llamamos <em>avanzado</em> a Emacs porque puede hacer mucho más que una simple inserción y borrado de texto. Puede controlar subprocesos, sangrar programas automáticamente, mostrar múltiples archivos a la vez, editar archivos remotos como si fueran archivos locales, y mucho más. Los comandos de edición de Emacs funcionan en términos de caracteres, palabras, líneas, frases, párrafos y páginas, así como de expresiones y comentarios en varios lenguajes de programación.</p>
<p><em>Autodocumentado</em> significa que en cualquier momento puede utilizar comandos especiales, conocidos como <em>comandos de ayuda</em>, para averiguar cuáles son sus opciones, o para averiguar qué hace
cualquier comando, o para encontrar todos los comandos que pertenecen a un tema determinado. Véase <aclass="reference internal"href="CapConSecciones/11_Ayuda.html#id1"><spanclass="std std-ref">11 Ayuda</span></a>.</p>
<p><em>Personalizable</em> significa que puede alterar fácilmente el comportamiento de los comandos de Emacs de maneras sencillas. Por ejemplo, si usa un lenguaje de programación en el que los comentarios empiezan con <codeclass="docutils literal notranslate"><spanclass="pre"><**</span></code> y terminan con <codeclass="docutils literal notranslate"><spanclass="pre">**></span></code>, puede decirle a los comandos de manipulación de comentarios de Emacs que usen esas cadenas (vea <aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#id13"><spanclass="std std-ref">27.5. Manipulación de Comentarios</span></a>). Por poner otro ejemplo, puede reenlazar los comandos básicos de movimiento del cursor (arriba, abajo, izquierda y derecha) a cualquier tecla del teclado que te resulte cómoda. Véase <aclass="reference internal"href="CapConSecciones/50_Personlzc.html#id1"><spanclass="std std-ref">50 Personalización</span></a>.</p>
<p><em>Personalizable</em> significa que puede alterar fácilmente el comportamiento de los comandos de Emacs de maneras sencillas. Por ejemplo, si usa un lenguaje de programación en el que los comentarios empiezan con <codeclass="docutils literal notranslate"><spanclass="pre"><**</span></code> y terminan con <codeclass="docutils literal notranslate"><spanclass="pre">**></span></code>, puede decirle a los comandos de manipulación de comentarios de Emacs que usen esas cadenas (vea <aclass="reference internal"href="CapConSecciones/27_EdDePrograms.html#id14"><spanclass="std std-ref">27.5. Manipulación de Comentarios</span></a>). Por poner otro ejemplo, puede reenlazar los comandos básicos de movimiento del cursor (arriba, abajo, izquierda y derecha) a cualquier tecla del teclado que te resulte cómoda. Véase <aclass="reference internal"href="CapConSecciones/50_Personlzc.html#id1"><spanclass="std std-ref">50 Personalización</span></a>.</p>
<p><em>Extensible</em> significa que puede ir más allá de la simple personalización y crear comandos completamente nuevos. Los nuevos comandos son simplemente programas escritos en lenguaje Lisp, que son ejecutados por el propio intérprete Lisp de Emacs. Los comandos existentes pueden incluso redefinirse en mitad de una sesión de edición, sin tener que reiniciar Emacs. La mayoría de los comandos de edición en Emacs están escritos en Lisp; las pocas excepciones podrían haber sido escritas en Lisp pero usan C en su lugar por eficiencia. Escribir una extensión es programar, pero los no programadores pueden usarla después. <strong>Ver Prefacio</strong> en Una Introducción a la Programación en Emacs Lisp, si quiere aprender programación en Emacs Lisp.</p>
tanomarcelo