Utilizzo di Emacs come IDE

Attualmente il mio flusso di lavoro con Emacs quando sto programmando in C o C ++ coinvolge tre finestre. Il più grande a destra contiene il file con cui sto lavorando. La sinistra è divisa in due, la parte inferiore è una shell che uso per scrivere o compilare comandi, e la parte superiore è spesso una sorta di documentazione o file README che voglio consultare mentre sto lavorando. Ora so che ci sono alcuni utenti Emacs piuttosto esperti là fuori, e sono curioso di sapere quali altri Emacs sono utili dal punto di vista funzionale se l'intenzione è quella di usarlo come IDE completo. In particolare, la maggior parte degli IDE di solito svolge queste funzioni in un modo o nell'altro:

• Editor del codice sorgente
• Compiler
• Debug
• Ricerca documentazione
• Controllo versione
• Funzionalità OO come la ricerca di classe e la finestra di ispezione degli oggetti

Per alcuni di questi, è abbastanza ovvio come Emacs possa adattarsi a queste funzioni, ma per quanto riguarda il resto? Inoltre, se un linguaggio specifico deve essere focalizzato su, direi che dovrebbe essere C ++.

Modifica: un utente ha sottolineato che avrei dovuto essere più specifico quando ho detto "che dire del resto". Principalmente ero curioso di un controllo efficiente della versione e della ricerca della documentazione. Ad esempio, in SLIME è abbastanza facile eseguire una rapida ricerca di iperspec su una funzione Lisp. Esiste un modo rapido per cercare qualcosa nella documentazione C ++ STL (ad esempio, se ho dimenticato l'esatta sintassi di hash_map )?

Dovrai essere specifico su cosa intendi per "il resto". Ad eccezione di Inspector oggetto (di cui sono a conoscenza), emacs fa tutto quanto sopra abbastanza facilmente:

• editore (ovvio)
• compilatore: basta eseguire M-x compilee immettere il comando di compilazione. Da lì in poi, puoi semplicemente M-x compilee utilizzare l'impostazione predefinita. Emacs acquisirà gli errori del compilatore C / C ++ (funziona meglio con GCC) e ti aiuta a navigare verso le righe con avvisi o errori.
• Debug - allo stesso modo, quando si desidera eseguire il debug, digitare M-x gdbe creerà un buffer gdb con associazioni speciali
• Documentation Lookup - emacs ha eccellenti collegamenti CScope per la navigazione del codice. Per altra documentazione: Emacs ha anche un lettore di pagine man e, per tutto il resto, c'è il web e i libri.
• controllo versione - ci sono molti collegamenti Emacs per vari backend VCS (CVS, SCCS, RCS, SVN, GIT tutti vengono in mente)

Modifica: realizzo la mia risposta sulla ricerca della documentazione relativa alla navigazione del codice. Ecco alcune informazioni aggiuntive:

• Ricerca di manpage, manuali informativi e documentazione Elisp dall'interno di emacs
• Ricerca della documentazione di Python da Emacs .

La ricerca su Google rivelerà senza dubbio ulteriori esempi.

Come mostra il secondo collegamento, è possibile cercare funzioni (e quant'altro) in altra documentazione, anche se non supportate immediatamente.

Devo raccomandare Emacs Code Browser come un ambiente IDE più "tradizionale" per emacs.

EDIT : ora consiglio vivamente Magit all'interfaccia VCS standard di emacs.

Invece di eseguire un comando make nella finestra della shell, hai provato a compilare Mx? Eseguirà il comando make, visualizzerà gli errori e in molti casi renderà molto semplice passare alla riga di codice che ha causato l'errore se l'output include nomi di file e numeri di riga.

Se sei un fan degli IDE, potresti anche voler dare un'occhiata al pacchetto speedbar di emacs (Mx speedbar). E, se non lo hai già fatto, scopri come utilizzare le tabelle dei tag per navigare nel tuo codice.

Ci sono angoli di emac che una volta scoperti ti rendono più produttivo in modi a cui non hai mai pensato. Come altri hanno già detto, usare i tag è un modo fantastico e veloce per ingrandire il codice sorgente e usare M- / (dabbrev-expand) spesso fa esattamente quello che ti aspetti quando completi un nome di variabile.

L'uso di si verifica è utile per ottenere un buffer con tutte le occorrenze di un'espressione regolare in un buffer. È molto utile quando si esegue il refactoring del codice e si cercano frammenti di codice o usi di variabili o se si utilizzano marcatori TODO nei file di origine e si desidera visitarli tutti.

le linee di flush, l'ordinamento di campi numerici, le funzioni di sostituzione-regexp e di rettangolo possono essere davvero utili per prendere un dump da qualche strumento e convertirlo in dati utili come un programma elisp o un foglio di calcolo delimitato da virgole.

Ho scritto una pagina su IDE come le cose che puoi fare con emacs

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

Imparare elisp è un altro ottimo modo per rispondere a te stesso cos'altro può fare Emacs oltre a quello che può fare un IDE tipico.

Ad esempio ho scritto un blog sulla scrittura di funzioni di supporto di Perforce come la colpa (scrivere da solo significa che puoi farlo funzionare esattamente come vuoi) ...

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

Ho anche scritto codice che crea dinamicamente commenti per una funzione specifica, che corrisponde agli standard di codifica con cui sto lavorando.

Nessuno dei miei codici elisp è particolarmente eccezionale, e la maggior parte esiste già nelle librerie, ma è davvero utile essere in grado di fare in modo che gli emacs facciano cose personalizzate che arrivano solo durante una giornata lavorativa.

Puoi trovare una descrizione dettagliata di emacs e l'integrazione del controllo versione sul mio sito . Sto anche lavorando ad un articolo sull'uso di Emacs come ambiente di sviluppo per molte lingue - C / C ++, Java, Perl, Lisp / Scheme, Erlang, ecc ...

Per il controllo della versione, ci sono diverse cose che puoi usare, a seconda del sistema di controllo della versione che usi. Ma alcune funzionalità sono comuni a tutte.

vc.el è il modo integrato per gestire il controllo della versione a livello di file. Ha backend per la maggior parte dei sistemi di controllo della versione. Ad esempio, il backend Subversion viene fornito con Emacs e ci sono backend git e altri disponibili da altre fonti.

Il comando più utile è Cx vv (vc-next-action) che esegue l'azione successiva appropriata per il file che si sta visitando. Ciò potrebbe significare l'aggiornamento dal repository o il commit delle modifiche, vc.el ricollega anche Cx Cq per archiviare e estrarre i file se si utilizza un sistema che ne ha bisogno (come RCS).

Altri comandi molto utili sono Cx vl e Cx v = che mostrano il registro e il diff corrente per il file che si sta utilizzando.

Ma per una vera produttività, dovresti evitare di usare i comandi vc.el a file singolo se non per cose semplici. Esistono diversi pacchetti che possono darti una panoramica dello stato dell'intero albero, darti più potere e per non parlare della capacità di creare commit coerenti che coprono diversi file.

Molti di questi sono fortemente influenzati o basati sui pcl-cvs / pcvs originali per CVS. Ci sono anche due di loro che viene fornito con la sovversione, psvn.el e dsvn.el . Ci sono pacchetti per git ecc.

Bene, tutti qui stanno dando suggerimenti perfetti per rendere emacs un IDE eccezionale.

Ma qualcuno dovrebbe tenere a mente che, quando personalizzi i tuoi emacs con molta estensione (specialmente con quelli per il controllo del tipo al volo, le ricerche di definizione delle funzioni ecc.) I tuoi emacs si caricheranno molto, molto lentamente per un editor.

Per ovviare a questo, consiglio vivamente di usare emacs in server mode.

È piuttosto semplice da usare, non è necessario personalizzare il file init. Hai solo bisogno di avviare emacs in modalità demone;

emacs --daemon

Questo creerà un server emacs, quindi puoi collegarlo dal terminale o dalla GUI. Consiglierei anche di creare alcuni alias per semplificare la chiamata.

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

In questo modo, emacs si accenderà anche più velocemente di gedit, promesso.

L'unico possibile problema qui, se stai eseguendo il demone emacs dal tuo utente occasionale, probabilmente non puoi connettere il server emacs come root.

Quindi, se è necessario aprire un file con accesso root; usa trampinvece. Esegui il tuo client emacs con il tuo normale utente e apri file come questo;

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

Questo mi ha semplificato la vita, in questo modo posso aprire il mio pesante IDE pitone personalizzato in millisecondi. È inoltre possibile aggiungere emacs --daemon all'avvio del sistema o creare un file desktop per emacsclient. Dipende da te.

Maggiori informazioni sul demone emacs e sul client emacs sono disponibili sul wiki;

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

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

Sono d'accordo che dovresti conoscere la compilazione di Mx (associa questo e Mx errore successivo a una breve sequenza di tasti).

Informazioni sui collegamenti per il controllo della versione (ad es. Vc-diff, vc-next-action, ecc.)

Guarda nei registri. Non solo puoi ricordare le posizioni nei buffer, ma le configurazioni dell'intera finestra (Cx rw - window-configuration-to-register).

Un punto di partenza (che potrebbe non essere ovvio) per esplorare le funzionalità VC di Emacs è Mx vc-next-action .

Esegue la "successiva operazione di controllo della versione logica" sul file corrente, a seconda dello stato del file e del backend VC. Quindi, se il file non è sotto il controllo della versione, lo registra, se il file è stato modificato, le modifiche vengono inviate ecc.

Ci vuole un po 'per abituarsi, ma lo trovo molto utile.

Il keybinding predefinito è Cx vv

C'è un TFS.el per l'integrazione di emacs in Microsoft TFS . Funziona con qualsiasi TFS, incluso il TFS che esegue Codeplex.com.

Passaggi di base per l'installazione:

1. Inserisci tfs.el nel percorso di caricamento.

2. Nel tuo file .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. anche nel tuo file .emacs, imposta le combinazioni di tasti locali o globali per i comandi tfs. così:

   (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)

compile, next-error e previous-error sono tutti comandi abbastanza importanti per lo sviluppo di C ++ in Emacs (funziona benissimo anche sull'output grep). Anche Etags, visit-tag-table e find-tag sono importanti. completamento.el è uno dei grandi hack non celebrati del 20 ° secolo e può accelerare il tuo hacking C ++ di un ordine di grandezza. Oh e non dimentichiamoci di Ediff.

Devo ancora imparare come usare il controllo versione senza visitare una shell, ma ora che sto eseguendo si impegna molto più frequentemente (con git) probabilmente dovrò farlo.

Potresti anche trovare la barra delle schede utile la . Emula l'unico comportamento che mi è sfuggito quando mi sono spostato da Eclipse a Emacs. Legato a "," e "." per passare alla barra delle schede precedente e successiva, ti fa rivivere dallo scambio del buffer di Ctrl-x b in ogni momento.

Sfortunatamente, la pagina web menzionata non fornisce la versione corretta da scaricare. La maggior parte delle versioni di Ubuntu, tuttavia, lo distribuiscono nei loro pacchetti emacs-goodies.

Uso emacs su Windows. il modulo di compilazione è carino, ma volevo che la compilazione fosse più intelligente sulla riga di comando di compilazione che suggerisce. È possibile utilizzare "Variabili di file" per specificarecompile-command , ma volevo qualcosa di un po 'più intelligente di così. Quindi ho scritto una piccola funzione per dare una mano. Indovina il comando di compilazione da utilizzare, per richiedere all'utente, durante l'esecuzionecompile .

La funzione indovina cerca un file vbproj o csproj o sln e, se trovato, suggerisce msbuild. Quindi esamina il nome del file buffer e, a seconda di ciò, suggerisce cose diverse. Un file .wxs significa che è un progetto WIX, e probabilmente vorrai creare un MSI, quindi la logica di ipotesi suggerisce un comando nmake per l'MSI. Se si tratta di un modulo Javascript, il suggerimento è di eseguire jslint-for-wsh.js per sfilare il file .js. Come fallback, suggerisce nmake.

Il codice che uso è simile al seguente:

(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)

Ho provato a farlo come "prima del consiglio" per la funzione di compilazione, ma non sono riuscito a farlo funzionare in modo soddisfacente. Così ho definito una nuova funzione e l'ho legata alla stessa combinazione di tasti che ho usato per compile.

EDIT ora c'è " smarter-compile.el " che porta questa idea un passo avanti.

Sulla ricerca della documentazione: dipende dai linguaggi di programmazione.

Le librerie C e le chiamate di sistema sono generalmente documentate nelle pagine man. Per quello puoi usare M-x man. Alcune cose potrebbero essere meglio documentate nelle pagine informative; usare M-x info.

Per elisp stesso, utilizzare C-h f. Per Python, utilizzare >>> help(<function, class, module>)nell'interprete.

Trovo che la maggior parte delle altre lingue offra documentazione in formato html. Per questo, prova un browser incorporato (io uso w3m). Imposta la tua BROWSERvariabile di ambiente su uno script wrapper emacsclient -e "(w3m-goto-url-new-session \"$@\")"(su * nix), nel caso in cui qualcosa possa aprire un browser e desideri che sia aperto all'interno di emacs.

So che questo è un post molto vecchio. Ma questa domanda è valida per i principianti di emacs.

IMO il modo migliore per usare emacs come ide è usare un protocollo di language server con emacs. Puoi trovare tutte le informazioni sui server delle lingue nel sito web collegato.

Per una rapida configurazione, ti esorto a visitare questa pagina eglot . Eglot IMO fa abbastanza bene il suo lavoro. Si integra bene con i pacchetti di completamenti automatici come la società. Fornisce riferimenti di ricerca e altro ancora.

Anche per un debugger, potresti aver bisogno di debugger specifici per lingue specifiche. Puoi usare gdb da emacs. Basta digitare M-x gdb.

Per compilare il codice, è meglio usare i comandi shell. Sto lavorando a questo progetto eproj . Ci vorrà un po 'per completarlo. Ma tutto ciò che fa è il comando shell della mappa al tipo di progetto. E costruisce il tuo progetto tramite shell. Fa lo stesso per eseguire il comando. Potrei aver bisogno di aiuto per completare questo progetto. Non è pronto per l'uso, ma se conosci un po 'di elisp puoi consultare il codice.

A parte questo, è sempre meglio usare il comando di compilazione emacs.

Per il controllo della versione, non ho ancora visto nessun altro pacchetto che possa eguagliare il potere di magit . È specifico di Git. Anche per git c'è un altro pacchetto git-timemachine, che trovo molto utile.

La ricerca degli oggetti e la ricerca di classe è fornita dal protocollo del server delle lingue.

Un albero di progetto può essere usato per un'interfaccia ide come con treemacs .

Esiste anche una libreria di interazione del progetto chiamata projectile .

Per il completamento automatico, trovo molto utile la modalità azienda .

Emacs veramente può essere fatto per fare qualsiasi cosa.

Negli ultimi anni, Clang è diventato una parte importante del supporto di Emacs C ++. Atila Neves ha tenuto un discorso su CppCon 2015: "Emacs come IDE C ++"

È un discorso di 16 minuti, in cui mostra soluzioni per i seguenti argomenti:

• Vai alla definizione
• Completamento automatico
• Evidenziazione della sintassi al volo
• Trova il file nel progetto

Le diapositive possono essere trovate qui .

Nello stile Unix o X windows, non so che esiste un IDE integrato che funzioni per tutto.

Per interagire con i debugger, solo un componente di un IDE, considera realgud . L'altra cosa che trovo utile sono i parser per i messaggi di localizzazione, in modo che se si dispone di una traccia dello stack di chiamate e si desidera modificare in un determinato punto del callstack, questa interfaccia front-end può farlo.

Di gran lunga questo programma potrebbe utilizzare il miglioramento. Ma poi potrebbe anche usare le persone che ci lavorano per migliorarlo.

Disclaimer: lavoro su realgud

Prova la modalità lsp. Ora puoi usare altre funzionalità IDE all'interno di emacs connettendoti al server. Cerca ulteriori informazioni: lsp-mode