it-swarm.it

Usando Emacs come un IDE

Attualmente il mio flusso di lavoro con Emacs quando sto codificando in C o C++ riguarda 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 lavoro. Ora so che ci sono alcuni utenti Emacs piuttosto esperti là fuori, e sono curioso di sapere quali altri Emacs funzionalmente sono utili se si intende usarlo come IDE completo. In particolare, la maggior parte degli IDE di solito soddisfano queste funzioni è una forma o un'altra:

  • Editor del codice sorgente
  • Compiler
  • Debug
  • Ricerca della documentazione
  • Controllo della versione
  • Funzionalità OO come la ricerca della classe e l'ispettore degli oggetti 

Per alcuni di questi, è abbastanza ovvio come Emacs possa adattarsi a queste funzioni, ma per quanto riguarda il resto? Inoltre, se una lingua specifica deve essere focalizzata, 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 controllo di versione efficiente, così come la ricerca di documentazione. Ad esempio, in SLIME è abbastanza facile fare una rapida ricerca hyperspec su una funzione LISP. C'è un modo rapido per cercare qualcosa nella documentazione di C++ STL (se ho dimenticato la sintassi esatta di hash_map , ad esempio)?

163
user7545

Dovrai essere specifico su cosa intendi con "il resto". Tranne che per l'ispettore degli oggetti (di cui sono a conoscenza), emacs fa tutto ciò abbastanza facilmente:

  • editor (ovvio)
  • compilatore - basta eseguire M-x compile e inserire il comando di compilazione. Da lì in poi, puoi solo M-x compile e usare il valore predefinito. Emacs catturerà gli errori del compilatore C/C++ (funziona meglio con GCC) e ti aiuterà a navigare verso le linee con avvertimenti o errori.
  • Debug - analogamente, quando si desidera eseguire il debug, digitare M-x gdb e creerà un buffer gdb con binding speciali
  • Ricerca documentazione - emacs ha eccellenti collegamenti CScope per la navigazione del codice. Per altra documentazione: Emacs ha anche un lettore di manpage, e per tutto il resto, c'è il web e i libri.
  • controllo della versione - ci sono molti legami di Emacs per vari back-end VCS (CVS, SCCS, RCS, SVN, GIT mi vengono in mente tutti)

Modifica: mi rendo conto che la mia risposta sulla ricerca della documentazione riguardava in realtà la navigazione del codice. Ecco alcune informazioni più precise: 

La ricerca di Google rivelerà senza dubbio ulteriori esempi.

Come mostra il secondo link, è possibile cercare le funzioni (e qualsiasi altra cosa) in altra documentazione, anche se non supportate immediatamente.

73
Ben Collins

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

EDIT: Adesso raccomando anche Magit molto oltre l'interfaccia VCS standard in emacs.

29
baudtack

Invece di eseguire un comando make nella finestra Shell, hai provato M-x compilare? Eseguirà il comando make, visualizzerà errori e in molti casi renderà molto semplice saltare 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 (M-x speedbar). E, se non lo hai già fatto, scopri come utilizzare le tabelle dei tag per navigare nel tuo codice.

19
Bryan Oakley

Ci sono angoli di emac che una volta scoperti ti rendono più produttivo in modi che non avresti mai pensato. Come altri hanno già detto, l'uso dei tag è un modo fantastico e veloce per ingrandire il codice sorgente e usare M-/(dabbrev-expand) spesso fa esattamente quello che ci si aspetta quando si completa un nome di variabile. 

L'utilizzo di occorrenza è utile per ottenere un buffer con tutte le occorrenze di un'espressione regolare in un buffer. Questo è molto utile quando si refactoring il codice e si cercano frammenti di codice o usi di variabili, o se si usano i marcatori TODO nei file sorgente e si desidera visitarli tutti.

linee a filo, ordinamento-campi numerici, sostituisci-regexp e rettangoli possono essere davvero utili per prelevare 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

Learning elisp è un altro ottimo modo per rispondere a te stesso cos'altro può fare Emacs al di là di ciò che un tipico IDE può fare. 

Per esempio, ho scritto sul blog di scrivere le funzioni di aiuto di Perforce come la colpa (scrivere per conto tuo 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 un codice che crea dinamicamente commenti per una funzione al punto, che corrisponde agli standard di codifica con cui sto lavorando. 

Nessuno del mio codice elisp è particolarmente grande, e la maggior parte di esso esiste già nelle librerie, ma è davvero utile essere in grado di fare emacs di cose personalizzate che emergono durante una giornata lavorativa. 

15
justinhj

Puoi trovare la descrizione dettagliata di emacs e l'integrazione del controllo della versione su il mio sito . Sto anche lavorando su un articolo sull'utilizzo di Emacs come ambiente di sviluppo per molte lingue - C/C++, Java, Perl, LISP/Scheme, Erlang, ecc ...

10
Alex Ott

Ok, tutti qui stanno dando consigli perfetti per rendere Emac un grande IDE. 

Ma chiunque dovrebbe tenere a mente che, quando si personalizzano i tuoi emac con molta estensione (specialmente con quelli per il controllo dei caratteri al volo, le funzioni di definizione delle definizioni, ecc.), I tuoi emacs caricheranno molto, molto lentamente per un editor. 

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

È abbastanza semplice da usare, non c'è bisogno di personalizzare il tuo file di init . Hai solo bisogno di avviare emacs in modalità daemon;

emacs --daemon

Questo creerà un server emacs, quindi potrai collegarlo dal terminale o dal gui. Ti consiglio anche di creare alcuni alias per rendere più semplice 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 illuminerà ancora più velocemente di gedit, promessa.

L'unico problema possibile qui, se si sta eseguendo il demone emacs dal proprio utente occasionale, probabilmente non si può connettere il server emacs come root

Quindi, se è necessario aprire un file con accesso root; usa invece tramp. Basta eseguire il tuo client emacs con il tuo normale utente e aprire file come questo;

C-x C-f
/Sudo:[email protected]/some/file/that/has/root/access/permissions
# on some linux distro it might be `/su:[email protected]` 

Ciò mi ha reso la vita più facile, in questo modo posso aprire il mio python personalizzato IDE in pochi millisecondi. Si potrebbe anche voler aggiungere emacs --daemon all'avvio del sistema o creare un file desktop per emacsclient. Dipende da te. 

Maggiori informazioni su emacs daemon ed emacs client possono essere trovati su wiki;

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

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

8
Muhammet Can

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

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 di versione. Ad esempio, il backend di Subversion viene fornito con Emacs, e ci sono git backend e altri disponibili da altre fonti.

Il comando più utile è C-x v v (vc-next-action) che esegue l'azione successiva appropriata per il file che stai visitando. Ciò potrebbe significare l'aggiornamento dal repository o il commit delle modifiche, inoltre vc.el rebinds C-x C-q per controllare i file in entrata e in uscita se si utilizza un sistema che ne ha bisogno (come RCS).

Altri comandi molto utili sono C-x v lC-x v = che mostra il log e la diff attuale per il file che stai utilizzando.

Ma per una vera produttività, dovresti evitare di usare i comandi vc.el a file singolo, tranne che per cose semplici. Ci sono diversi pacchetti che possono darti una panoramica dello stato del tuo intero albero e darti più potenza, e per non parlare della possibilità di creare commit coerenti che coprano diversi file.

La maggior parte di questi sono pesantemente influenzati o basati sull'originale pCL-cvs/pCVs per CVS. Ce ne sono anche due che vengono con Subversion, psvn.eldsvn.el. Ci sono pacchetti per git ecc.

8
dkagedal

Sono d'accordo sul fatto che dovresti imparare come compilare M-x (associare quello e M-x prossimo-errore a una sequenza di tasti brevi).

Ulteriori informazioni sui binding per il controllo della versione (ad esempio vc-diff, vc-next-action, ecc.)

Guarda nei registri. Non solo è possibile ricordare posizioni nei buffer ma configurazioni dell'intera finestra (C-x r w - configurazione-finestra-a-registro).

7
HD.

Un punto di partenza (che può essere non ovvio) per esplorare le caratteristiche VC di Emacs è M-x vc-next-action

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

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

La combinazione di tasti predefinita è C-x v v

6
Chopmo

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. Posiziona tfs.el nel tuo percorso di carico.

  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 i binding di chiavi 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)
    
4
Cheeso

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

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

3
jfm3

Io uso emacs su Windows. il modulo di compilazione è Nice, ma volevo compilare per essere più intelligente sulla linea di comando che suggerisce. È possibile usare "File Variables" per specificare compile-command , ma volevo qualcosa di un po 'più intelligente di quello. Così ho scritto una piccola funzione per dare una mano. Indovina il comando compile da utilizzare, per richiedere all'utente, quando esegue compile

La funzione guess cerca un file vbproj o csproj o sln e, se trovato, suggerisce msbuild. Quindi guarda il nome del file del buffer e, a seconda di ciò, suggerisce cose diverse. Un file .wxs significa che si tratta di un progetto WIX e probabilmente si desidera 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 filtrare il file .js. Come ripiego, suggerisce nmake. 

Il codice che uso assomiglia a questo:

(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 di un consiglio" per la funzione di compilazione ma non riuscivo 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 prende questa idea un ulteriore passo avanti.

3
Cheeso

Potresti anche trovare tabbar utile. Emula l'unico comportamento che mi è mancato durante il passaggio da Eclipse ad Emacs. Associato a "," e "." per passare alla barra delle schede precedente e successiva, ti fa rivivere dal cambiare il buffer con Ctrl-x b tutto il tempo.

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

3
wr.

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 language server protocol con emacs. È possibile trovare tutte le informazioni sui server di lingue nel sito Web collegato. 

Per una rapida configurazione, ti esorto a visitare questa pagina eglot . IMO eglot fa piuttosto bene il suo lavoro. Si integra bene con i pacchetti di completamenti automatici come la compagnia. Fornisce riferimenti di riferimento 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 tuo codice, è meglio usare i comandi Shell. Sto lavorando a questo progetto eproj . Ci vorrà un po 'per completarlo. Ma tutto ciò che fa è mappare il comando Shell al tipo di progetto. E costruisce progetti via 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 elis puoi passare attraverso 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 corrisponda alla potenza di magit . È specifico di git. Anche per git c'è un altro pacchetto git-timemachine, che trovo molto utile.

La ricerca dell'oggetto e la ricerca della classe sono fornite dal protocollo del server delle lingue. 

Un albero del progetto può essere usato per un'interfaccia simile a treemacs .

C'è anche un progetto Interaction Library chiamato projectile .

Per il completamento automatico, trovo company-mode molto utile. 

Veramente emacs può essere fatto per fare qualsiasi cosa.

2
sidharth arya

Alla ricerca della documentazione: dipende dal tuo linguaggio di programmazione.

Le librerie C e le chiamate di sistema sono in genere documentate nelle pagine man. Per quello puoi usare M-x man. Alcune cose possono essere meglio documentate nelle pagine di informazioni; usa M-x info.

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

Trovo che la maggior parte delle altre lingue offra documentazione in formato html. Per quello, prova un browser incorporato (io uso w3m). Imposta la tua variabile d'ambiente BROWSER su uno script di wrapper attorno a emacsclient -e "(w3m-goto-url-new-session \"[email protected]\")" (su * nix), nel caso in cui qualcosa potrebbe aprire un browser e vuoi che venga aperto all'interno di emacs.

2
Jonas Kölker

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++"

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

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

Le diapositive possono essere trovate qui .

1
Philipp Claßen

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

Per l'interazione con i debugger, solo un componente di un IDE, considera realgud . L'altra cosa che ho trovato utile sono i parser per i messaggi di posizione, in modo che se si dispone di una traccia di stack di chiamata e si desidera modificare in un punto particolare nel callstack, questa interfaccia front-end può farlo. 

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

Disclaimer: lavoro su realgud

0
rocky