Usando Emacs como un IDE

Actualmente, mi flujo de trabajo con Emacs cuando estoy codificando en C o C ++ implica tres ventanas. El más grande a la derecha contiene el archivo con el que estoy trabajando. La izquierda se divide en dos, la parte inferior es un shell que utilizo para escribir compilar o hacer comandos, y la parte superior es a menudo algún tipo de documentación o archivo README que quiero consultar mientras estoy trabajando. Ahora sé que hay algunos usuarios bastante expertos de Emacs, y tengo curiosidad por saber qué otros Emacs son útiles funcionalmente si la intención es usarlo como un IDE completo. Específicamente, la mayoría de los IDE generalmente cumplen estas funciones de una forma u otra:

• Editor de código fuente
• Compilador
• Depuración
• Búsqueda de documentación
• Control de versiones
• Funciones OO como búsqueda de clase e inspector de objetos

Para algunos de estos, es bastante obvio cómo Emacs puede adaptarse a estas funciones, pero ¿qué pasa con el resto? Además, si un lenguaje específico debe enfocarse, diría que debería ser C ++.

Editar: Un usuario señaló que debería haber sido más específico cuando dije 'qué pasa con el resto'. Principalmente tenía curiosidad sobre el control de versiones eficiente, así como la búsqueda de documentación. Por ejemplo, en SLIME es bastante fácil hacer una búsqueda rápida de hiperespecificación en una función Lisp. ¿Hay una manera rápida de buscar algo en la documentación de C ++ STL (si olvidé la sintaxis exacta de hash_map , por ejemplo)?

Tendrás que ser específico en cuanto a lo que quieres decir con "el resto". Excepto por el inspector de objetos (que yo sepa), emacs hace todo lo anterior con bastante facilidad:

• editor (obvio)
• compilador: simplemente ejecute M-x compilee ingrese su comando de compilación. A partir de ahí, puede M-x compileusar y usar el predeterminado. Emacs capturará los errores del compilador C / C ++ (funciona mejor con GCC) y lo ayudará a navegar a líneas con advertencias o errores.
• Depuración: de manera similar, cuando desee depurar, escriba M-x gdby creará un búfer gdb con enlaces especiales
• Búsqueda de documentación: emacs tiene excelentes enlaces de CScope para la navegación de código. Para otra documentación: Emacs también tiene un lector de páginas de manual, y para todo lo demás, está la web y los libros.
• Control de versiones: hay muchos enlaces de Emacs para varios backends VCS (CVS, SCCS, RCS, SVN, GIT vienen a mi mente)

Editar: me doy cuenta de que mi respuesta sobre la búsqueda de documentación realmente se refería a la navegación de código. Aquí hay más información sobre el punto:

• Buscar páginas de manual, manuales de información y documentación de Elisp desde emacs
• Buscar documentación de Python desde Emacs .

La búsqueda en Google sin duda revelará más ejemplos.

Como se muestra en el segundo enlace, se puede buscar funciones (y lo que sea) en otra documentación, incluso si no es compatible de inmediato.

Tengo que recomendar Emacs Code Browser como un entorno de estilo IDE más "tradicional" para emacs.

EDITAR : ahora también recomiendo a Magit por encima de la interfaz VCS estándar en emacs.

En lugar de ejecutar un comando make en la ventana de shell, ¿ha intentado compilar Mx? Ejecutará su comando make, mostrará errores y, en muchos casos, hará que sea muy fácil saltar a la línea de código que causó el error si la salida incluye nombres de archivo y números de línea.

Si eres fanático de los IDEs, es posible que también quieras ver el paquete de barra de velocidad de emacs (barra de velocidad Mx). Y, si aún no lo ha hecho, obtenga información sobre cómo usar las tablas de etiquetas para navegar por su código.

Hay rincones de emacs que una vez descubiertos te hacen más productivo de formas que nunca pensaste. Como otros han mencionado, el uso de etiquetas es una forma fantástica y rápida de acercarse a su código fuente y usar M- / (dabbrev-expand) a menudo hace exactamente lo que espera al completar un nombre de variable.

El uso de producir es útil para obtener un búfer con todas las ocurrencias de una expresión regular en un búfer. Eso es realmente útil cuando se refactoriza el código y se buscan fragmentos de código o usos de variables, o si usa marcadores TODO en sus archivos fuente y desea visitarlos a todos.

las líneas de lavado, los campos de clasificación numérica, la sustitución de expresiones regulares y las funciones de rectángulo pueden ser realmente útiles para realizar un volcado de alguna herramienta y convertirla en datos útiles, como un programa elisp o una hoja de cálculo delimitada por comas.

Escribí una página sobre IDE como cosas que puedes hacer con emacs

http://justinsboringpage.blogspot.com/2007/09/11-visual-studio-tricks-in-emacs.html

Aprender elisp es otra gran manera de responder por ti mismo qué más puede hacer emacs más allá de lo que puede hacer un IDE típico.

Por ejemplo, escribí en un blog sobre escribir funciones de ayuda de Perforce como culpar (escribir las tuyas propias significa que puedes hacer que se comporte exactamente como quieras) ...

http://justinsboringpage.blogspot.com/2009/01/who-changed-line-your-working-on-last.html

También he escrito código que crea dinámicamente comentarios para una función en el punto, que coincide con los estándares de codificación con los que estoy trabajando.

Ninguno de mi código elisp es particularmente bueno, y la mayor parte ya existe en bibliotecas, pero es realmente útil poder hacer que emacs haga cosas personalizadas que surgen durante un día hábil.

Puede encontrar una descripción detallada de emacs y la integración del control de versiones en mi sitio . También estoy trabajando en un artículo sobre el uso de Emacs como entorno de desarrollo para muchos lenguajes: C / C ++, Java, Perl, Lisp / Scheme, Erlang, etc.

Para el control de versiones, hay varias cosas que puede usar, dependiendo del sistema de control de versiones que use. Pero parte de la funcionalidad es común a todos ellos.

vc.el es la forma integrada de manejar el control de versiones a nivel de archivo. Tiene backends para la mayoría de los sistemas de control de versiones. Por ejemplo, el backend de Subversion viene con Emacs, y hay backends git y otros disponibles de otras fuentes.

El comando más útil es Cx vv (vc-next-action) que realiza la siguiente acción adecuada para el archivo que está visitando. Esto podría significar actualizar desde el repositorio o confirmar sus cambios, vc.el también vuelve a vincular Cx Cq para registrar y retirar archivos si está utilizando un sistema que lo necesita (como RCS).

Otros comandos muy útiles son Cx vl y Cx v = que le muestran el registro y la diferencia actual del archivo que está utilizando.

Pero para una productividad real, debe evitar usar los comandos vc.el de un solo archivo que no sean para cosas simples. Hay varios paquetes que pueden brindarle una descripción general del estado de todo su árbol y darle más poder, sin mencionar la capacidad de crear confirmaciones coherentes que abarcan varios archivos.

La mayoría de estos están fuertemente influenciados o basados ​​en el pcl-cvs / pcvs original para CVS. Incluso hay dos de ellos que viene con la subversión, psvn.el y dsvn.el . Hay paquetes para git, etc.

De acuerdo, todos aquí están dando pistas perfectas para hacer de emacs un gran IDE.

Pero cualquiera debe tener en cuenta que, cuando personaliza sus emacs con mucha extensión (especialmente con los de verificación de tipo sobre la marcha, búsquedas de definición de funciones, etc.), sus emacs se cargarán muy, muy lentamente para un editor.

Para solucionar esto, recomiendo utilizar emacs en server mode.

Es bastante simple de usar, no es necesario personalizar su archivo de inicio. Solo necesita iniciar emacs en modo demonio;

emacs --daemon

Esto creará un servidor emacs, luego puede conectarlo desde la terminal o desde la interfaz gráfica de usuario. También recomendaría crear algunos alias para facilitar la llamada.

alias ec="emacsclient -t"
alias ecc="emacsclient -c &"
# some people also prefer this but no need to fight here;
alias vi="emacsclient -t"

De esta manera, emacs se activará aún más rápido que gedit, lo prometo.

El único problema posible aquí, si está ejecutando emacs daemon de su usuario casual, probablemente no pueda conectar el servidor emacs como root.

Entonces, si necesita abrir un archivo que tiene acceso de root; utilizar trampen su lugar. Simplemente ejecute su cliente emacs con su usuario normal y abra archivos como este;

C-x C-f
/sudo:root@localhost/some/file/that/has/root/access/permissions
# on some linux distro it might be `/su:root@...` 

Esto me facilitó la vida, de esta manera puedo abrir mi pesado IDE de Python personalizado en milisegundos. También puede agregar emacs --daemon al inicio de su sistema, o crear un archivo de escritorio para emacsclient. Eso depende de usted.

Puede encontrar más información sobre emacs daemon y emacs client en wiki;

http://www.emacswiki.org/emacs/EmacsAsDaemon

http://www.emacswiki.org/emacs/EmacsClient

Estoy de acuerdo en que debe aprender sobre la compilación Mx (vincular eso y Mx next-error a una secuencia de teclas corta).

Obtenga información sobre los enlaces para el control de versiones (por ejemplo, vc-diff, vc-next-action, etc.)

Mira en los registros. No solo puede recordar ubicaciones en buffers sino también configuraciones de ventanas completas (Cx rw - window-configuration-to-register).

Un punto de partida (que puede no ser obvio) para explorar las características de VC de Emacs es Mx vc-next-action .

Realiza la "siguiente operación de control de versión lógica" en el archivo actual, según el estado del archivo y el backend de VC. Entonces, si el archivo no está bajo control de versión, lo registra, si el archivo ha sido modificado, los cambios se envían, etc.

Toma un poco acostumbrarse, pero me parece muy útil.

La combinación de teclas predeterminada es Cx vv

Hay un TFS.el para la integración de emacs en Microsoft TFS . Funciona con cualquier TFS, incluido el TFS que ejecuta Codeplex.com.

Pasos básicos para la configuración:

1. Coloque tfs.el en su ruta de carga.

2. En su archivo .emacs:

   (require 'tfs)
   (setq tfs/tf-exe  "c:\\vs2008\\common7\\ide\\tf.exe")
   (setq tfs/login "/login:domain\\userid,password")
         -or-
   (setq tfs/login (getenv "TFSLOGIN"))  ;; if you have this set

3. también en su archivo .emacs, establezca enlaces de teclas locales o globales para los comandos tfs. al igual que:

   (global-set-key  "\C-xvo" 'tfs/checkout)
   (global-set-key  "\C-xvi" 'tfs/checkin)
   (global-set-key  "\C-xvp" 'tfs/properties)
   (global-set-key  "\C-xvr" 'tfs/rename)
   (global-set-key  "\C-xvg" 'tfs/get)
   (global-set-key  "\C-xvh" 'tfs/history)
   (global-set-key  "\C-xvu" 'tfs/undo)
   (global-set-key  "\C-xvd" 'tfs/diff)
   (global-set-key  "\C-xv-" 'tfs/delete)
   (global-set-key  "\C-xv+" 'tfs/add)
   (global-set-key  "\C-xvs" 'tfs/status)
   (global-set-key  "\C-xva" 'tfs/annotate)
   (global-set-key  "\C-xvw" 'tfs/workitem)

compilar, siguiente error y error anterior son comandos bastante importantes para el desarrollo de C ++ en Emacs (también funciona muy bien en la salida grep). Etags, visit-tags-table y find-tag también son importantes. complete.el es uno de los mejores hacks no reconocidos del siglo XX, y puede acelerar su piratería C ++ en un orden de magnitud. Ah, y no olvidemos el ediff.

Todavía tengo que aprender a usar el control de versiones sin visitar un shell, pero ahora que estoy ejecutando commits con mucha más frecuencia (con git) probablemente tendré que hacerlo.

También puede encontrar útil la barra de pestañas . Emula el único comportamiento que eché de menos al pasar de Eclipse a Emacs. Vinculado a "," y "." para pasar a la barra de pestañas anterior y siguiente, lo libera de cambiar el búfer con Ctrl-x b todo el tiempo.

Desafortunadamente, la página web mencionada no proporciona la versión correcta para descargar. Sin embargo, la mayoría de las versiones de Ubuntu lo entregan en sus paquetes emacs-goodies.

Yo uso emacs en Windows. el módulo de compilación es bueno, pero quería que la compilación fuera más inteligente con respecto a la línea de comandos de compilación que sugiere. Es posible usar "Variables de archivo" para especificarcompile-command , pero quería algo un poco más inteligente que eso. Entonces escribí una pequeña función para ayudar. Adivina el comando de compilación que se debe usar, para avisar al usuario cuando se ejecuta compile.

La función de conjetura busca un archivo vbproj o csproj o sln, y si se encuentra, sugiere msbuild. Luego mira el nombre del archivo de búfer y, dependiendo de eso, sugiere cosas diferentes. Un archivo .wxs significa que es un proyecto WIX, y es probable que desee construir un MSI, por lo que la lógica de conjetura sugiere un comando nmake para el MSI. Si se trata de un módulo Javascript, la sugerencia es ejecutar jslint-for-wsh.js para unir el archivo .js. Como alternativa, sugiere nmake.

El código que uso se ve así:

(defun cheeso-guess-compile-command ()
  "set `compile-command' intelligently depending on the
current buffer, or the contents of the current directory."
  (interactive)
  (set (make-local-variable 'compile-command)
       (cond
        ((or (file-expand-wildcards "*.csproj" t)
             (file-expand-wildcards "*.vcproj" t)
             (file-expand-wildcards "*.vbproj" t)
             (file-expand-wildcards "*.shfbproj" t)
             (file-expand-wildcards "*.sln" t))
         "msbuild ")

        ;; sometimes, not sure why, the buffer-file-name is
        ;; not set.  Can use it only if set.
        (buffer-file-name
         (let ((filename (file-name-nondirectory buffer-file-name)))
           (cond

            ;; editing a .wxs (WIX Soluition) file
            ((string-equal (substring buffer-file-name -4) ".wxs")
             (concat "nmake "
                     ;; (substring buffer-file-name 0 -4) ;; includes full path
                     (file-name-sans-extension filename)
                     ".msi" ))

            ;; a javascript file - run jslint
            ((string-equal (substring buffer-file-name -3) ".js")
             (concat (getenv "windir")
                     "\\system32\\cscript.exe c:\\users\\cheeso\\bin\\jslint-for-wsh.js "
                     filename))

            ;; something else - do a typical .exe build
            (t
             (concat "nmake "
                     (file-name-sans-extension filename)
                     ".exe")))))
        (t
         "nmake "))))


(defun cheeso-invoke-compile-interactively ()
  "fn to wrap the `compile' function.  This simply
checks to see if `compile-command' has been previously set, and
if not, invokes `cheeso-guess-compile-command' to set the value.
Then it invokes the `compile' function, interactively."
  (interactive)
  (cond
   ((not (boundp 'cheeso-local-compile-command-has-been-set))
    (cheeso-guess-compile-command)
    (set (make-local-variable 'cheeso-local-compile-command-has-been-set) t)))
  ;; local compile command has now been set
  (call-interactively 'compile))

;; in lieu of binding to `compile', bind to my monkeypatched function
(global-set-key "\C-x\C-e"  'cheeso-invoke-compile-interactively)

Intenté hacer esto como "consejo previo" para la función de compilación, pero no pude hacer que funcionara satisfactoriamente. Así que definí una nueva función y la vinculé a la misma combinación de teclas que he estado usando compile.

EDITAR ahora hay " smarter-compile.el " que lleva esta idea un paso más allá.

En la búsqueda de documentación: eso depende de su (s) lenguaje (s) de programación.

Las bibliotecas C y las llamadas al sistema generalmente se documentan en páginas de manual. Para eso puedes usar M-x man. Algunas cosas pueden documentarse mejor en páginas de información; uso M-x info.

Para elisp mismo, use C-h f. Para python, usar >>> help(<function, class, module>)en el intérprete.

Encuentro que la mayoría de los otros idiomas ofrecen documentación en formato html. Para eso, intente con un navegador incrustado (uso w3m). Establezca su BROWSERvariable de entorno en un script de envoltura alrededor emacsclient -e "(w3m-goto-url-new-session \"$@\")"(en * nix), en caso de que algo pueda abrir un navegador y desee que se abra dentro de emacs.

Sé que esta es una publicación muy antigua. Pero esta pregunta es válida para principiantes de emacs.

En mi opinión, la mejor manera de usar emacs como ide es usar un protocolo de servidor de idiomas con emacs. Puede encontrar toda la información sobre los servidores de idiomas en el sitio web vinculado.

Para una configuración rápida, le recomiendo que vaya a esta página eglot . IMO eglot hace su trabajo bastante bien. Se integra bien con paquetes de autocompletado como empresa. Proporciona referencias de búsqueda y más.

También para un depurador, es posible que necesite depuradores específicos para idiomas específicos. Puede usar gdb desde emacs. Solo escribe M-x gdb.

Para compilar su código, es mejor usar comandos de shell. Estoy trabajando en este proyecto eproj . Tomará un tiempo completarlo. Pero todo lo que hace es asignar el comando de shell al tipo de proyecto. Y construye tu proyecto a través de shell. Hace lo mismo para ejecutar el comando. Es posible que necesite ayuda para completar este proyecto. No está listo para usar, pero si conoce un poco de elisp, puede revisar el código.

Aparte de eso, siempre es mejor usar el comando de compilación emacs.

Para el control de versiones, todavía no he visto ningún otro paquete que pueda igualar el poder del magit . Es específico de git. También para git hay otro paquete git-timemachine, que encuentro muy útil.

La búsqueda de objetos y la búsqueda de clases es proporcionada por el protocolo del servidor de idiomas.

Un árbol de proyecto se puede usar para ide como interfaz con treemacs .

También hay una biblioteca de interacción de proyectos llamada proyectil .

Para la finalización automática, encuentro el modo empresa muy útil.

Realmente se puede hacer que emacs haga cualquier cosa.

En los últimos años, Clang se convirtió en una parte importante del soporte de Emacs C ++. Atila Neves habló sobre CppCon 2015: "Emacs como IDE de C ++"

Es una charla de 16 minutos, donde muestra soluciones para los siguientes temas:

• Saltar a definición
• Autocompletado
• Resaltado de sintaxis sobre la marcha
• Buscar archivo en proyecto

Las diapositivas se pueden encontrar aquí .

En el estilo de Windows Unix o X, no sé si hay un IDE integrado que funcione para todo.

Para interactuar con depuradores, solo un componente de un IDE, considere realgud . La otra cosa que me parece útil son los analizadores de mensajes de ubicación, de modo que si tiene un seguimiento de la pila de llamadas y desea editar en un lugar en particular en la pila de llamadas, esta interfaz front-end puede hacer eso.

Con mucho, este programa podría mejorar. Pero también podría usar personas que trabajan en él para mejorarlo.

Descargo de responsabilidad: trabajo en realgud

Prueba el modo lsp. Ahora puede usar otra funcionalidad IDE dentro de emacs que se conecta al servidor. Busque más información: lsp-mode