Domanda

Attualmente il mio flusso di lavoro con Emacs, quando io sono la codifica in C o C++, che prevede tre finestre.Il più grande sulla destra contiene il file che sto lavorando con.La sinistra è divisa in due, la parte inferiore di essere un guscio che io uso per tipo in fase di compilazione o di rendere i 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 abbastanza esperto di Emacs utenti là fuori, e io sono curioso di sapere cosa gli altri Emacs funzionalmente è utile se l'intenzione è di usarlo come un completo IDE.In particolare, l'Ide di solito di adempiere a queste funzioni è una forma o nell'altra:

  • Editor di codice sorgente
  • Compilatore
  • Il debug
  • Documentazione Ricerca
  • Il Controllo Di Versione
  • OO caratteristiche come la classe e la ricerca oggetto di ispezione

Per alcuni di questi, è abbastanza ovvio come Emacs può adattarsi a queste funzioni, ma il resto?Inoltre, se una lingua specifica, deve essere a fuoco, direi che dovrebbe essere C++.

Edit: Un utente ha sottolineato che avrei dovuto essere più specifico quando le ho detto: "per quanto riguarda il resto'.Soprattutto ero curioso di sapere efficiente di controllo di versione, come pure la documentazione di ricerca.Per esempio, nella MELMA, è abbastanza facile fare una rapida hyperspec ricerca su una funzione Lisp.C'è un modo rapido per cercare qualcosa in C++ STL documentazione (se ho dimenticato la sintassi esatta di hash_map, per esempio)?

È stato utile?

Soluzione

Dovrete essere specifico su cosa si intende per "il resto".Tranne che per l'oggetto di ispezione (che I"m a conoscenza di), emacs fa tutto il sopra abbastanza facilmente:

  • editor (ovvio)
  • compilatore - basta eseguire M-x compile e immettere il comando di compilazione.Da lì, si può solo M-x compile e utilizzare l'impostazione predefinita.Emacs catturerà il compilatore C/C++ errori (funziona meglio con GCC) e vi aiutano a navigare a righe con avvisi o errori.
  • Debug - allo stesso modo, quando si desidera eseguire il debug, tipo M-x gdb per creare un gdb buffer con particolare associazioni
  • Documentazione di Riferimento - emacs è eccellente CScope associazioni per il codice di navigazione.Per altra documentazione:Emacs ha anche una pagina di manuale lettore, e per tutto il resto, c'è il web e libri.
  • il controllo di versione - ci sono un sacco di Emacs associazioni per vari VCS backend (CVS, CSSC, RCS, SVN, GIT tutti vengono in mente)

Edit:Mi rendo conto che la mia risposta circa la documentazione di ricerca davvero riguardava il codice di navigazione.Ecco alcuni altri per-il-info point:

Google ricerca sarà senza dubbio rivelano ulteriori esempi.

Il secondo link mostra, la ricerca di funzioni (e altro) in altra documentazione può essere fatto, anche se non è sostenuto dalla scatola.

Altri suggerimenti

Devo raccomandare Emacs Codice Del Browser come la più "tradizionale" IDE ambiente in stile emacs.

MODIFICA:Anche io ora consiglia di Magit molto più standard VCS interfaccia in emacs.

Invece di eseguire un comando make nella finestra di shell, hai provato con M-x compilare?Verrà eseguito il comando make, errori di visualizzazione, e in molti casi rendono molto facile saltare alla riga di codice che ha causato l'errore se l'output include i nomi di file e numeri di riga.

Se sei un fan di Idee, si potrebbe anche voler guardare emacs' speedbar pacchetto (M-x contemporanea).E, se non l'hai già fatto, imparare ad usare i tag tabelle per navigare il vostro codice.

Ci sono angoli di emacs che, una volta scoperto rendere più produttivo in modi non avete mai pensato.Come altri hanno detto, l'uso di etichette è un fantastico e veloce per ingrandire tutto il codice sorgente e l'utilizzo di M-/ (dabbrev-espandere) spesso fa esattamente ciò che ci si aspetta quando il completamento di un nome di variabile.

Utilizzando verificarsi è utile per ottenere un buffer di tutte le occorrenze di una espressione regolare in un buffer.Questo è davvero utile quando il refactoring del codice e in cerca di frammenti di codice o usi delle variabili, o se si utilizza TODO marker nel file di origine e si desidera visitare.

flush-linee di sorta numerici per i campi di sostituire-regexp e rettangolo funzioni può essere davvero utile per scattare una discarica da qualche strumento di conversione di dati utili come un elisp programma o di una virgola delimitato foglio di calcolo.

Ho scritto una pagina su IDE, come cose che si possono fare con emacs

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

Apprendimento elisp è un altro ottimo modo per rispondere per te cos'altro emacs può fare al di là di ciò che un tipico IDE può fare.

Ad esempio, io ho scritto un blog su di scrittura Necessariamente le funzioni di supporto, come la colpa (la scrittura di un proprio mezzo si può fare si comportano esattamente come si desidera)...

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 in un punto, che corrisponde a standard di codifica sto lavorando con.

Nessuno dei miei elisp codice è particolarmente grande, e la maggior parte di esso esiste già nelle librerie, ma è molto utile per essere in grado di fare emacs personalizzata roba che appena esce durante una giornata di lavoro.

È possibile trovare una descrizione dettagliata di emacs & controllo di versione di integrazione il mio sito.Sto anche lavorando su un articolo sull'uso di Emacs come Ambiente di Sviluppo per molte lingue - C/C++, Java, Perl, Lisp/Schema, Erlang, ecc...

Per il controllo di versione, ci sono diverse cose che è possibile utilizzare, a seconda della versione del sistema di controllo in uso.Ma alcune delle funzionalità è comune a tutti loro.

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

Il più utile di comando è C-x v v (vc-next-azione) che non appropriata azione successiva per il file che si sta visitando.Questo potrebbe significare l'aggiornamento dal repository o inviare le vostre modifiche, vc.el anche riassocia C-x C-d per check in e check out file se si utilizza un sistema che ha bisogno (come RCS).

Altri comandi utili sono C-x v l e C-x v = che mostrano il registro e corrente diff per il file che si sta utilizzando.

Ma per la reale produttività, si dovrebbe evitare l'uso di un singolo file vc.el comandi rispetto per le cose semplici.Ci sono diversi pacchetti che possono dare una panoramica dello stato dell'intero albero, e vi darà più energia, e per non parlare della possibilità di creare coerente impegna spanning diversi file.

La maggior parte di questi sono fortemente influenzati o basato sull'originale pcl-cvs/pcvs per il CVS.Ci sono anche due di loro che viene fornito con subversion, psvn.el e dsvn.el.Ci sono pacchetti per git etc.

Va bene, qui tutti mi perfetti consigli per rendere la emacs un ottimo IDE.

Ma chiunque dovrebbe tenere a mente che, quando si personalizza il tuo emacs con un sacco di estensione (in particolare con quelli per il tipo di controllo al volo, definizione di funzione, ricerche, ecc) il tuo emacs caricare molto, molto lento per un editor.

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

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

emacs --daemon

Questo creerà un emacs server, quindi si può collegare sia da terminale, o da gui.Vorrei anche raccomandare di creare qualche alias per rendere più facile 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 fuoco anche più veloce di gedit, promessa.

L'unico possibile problema qui, se si esegue emacs demone dal tuo utente casuale, probabilmente non si può collegare emacs server root.

Quindi, se avete bisogno di aprire un file che ha l'accesso di root;utilizzare tramp invece.Basta eseguire il emacs client con un normale utente e i file aperti 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 ha reso la mia vita più facile, posso aprire il mio pesante personalizzato python IDE in millisecondi in questo modo.Si potrebbe aggiungere anche emacs --daemon di avvio del sistema, o creare un file sul desktop per emacsclient.Thats a voi.

Di più su emacs demone e emacs client può essere trovato alla wiki;

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

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

Sono d'accordo che si dovrebbe imparare a conoscere M-x compilare bind (che e M-x next-errore di una breve sequenza di tasti).

Conoscere le associazioni per il controllo di versione (es.vc-diff, vc-next-azione, etc.)

Guardare attraverso i registri.Non solo in grado di ricordare le posizioni nel buffer, ma tutta la finestra configurazioni (C-x r w -- finestra di configurazione per la registrazione).

Un punto di partenza (che può non essere evidente) per esplorare la VC caratteristiche di Emacs è M-x vc-next-azione.

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

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

Di Default azione è C-x v v

C'è un TFS.el per emacs integrazione di Microsoft TFS.Funziona con qualsiasi tipo di TFS, tra cui il TFS che corre Codeplex.com.

Procedura di base per l'installazione:

  1. Luogo di tfs.el tuo carico di percorso.

  2. Nel vostro .emacs file: 

    (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 .emacs file, impostare locale o globale, le associazioni di tasti per tfs comandi.in questo modo:

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

compilare, di prossima errore, e precedenti-errore sono tutte belle, importanti comandi per sviluppo C++ in Emacs (funziona alla grande su grep uscita troppo).Etag, visita-etichette-tavolo e trovare-tag sono importanti pure.di completamento.el è uno dei grandi celebrati hack del 20 ° secolo, e può accelerare il C++ hacking di un ordine di grandezza.Oh, e non dimentichiamo ediff.

Devo ancora imparare a usare il controllo di versione senza visitare una shell, ma ora che sto correndo si impegna in modo molto più frequentemente (con git) sarà probabilmente necessario.

Si potrebbe anche trovare tabbar utile.Emula l'unico comportamento che ho perso quando ci si sposta da Eclipse per Emacs.Legati a "," e "." per il passaggio alla precedente e successiva tab bar, si rivive voi di passare il buffer di Ctrl-x b per tutto il tempo.

Purtroppo, la citata pagina web non fornisce una versione corretta per il download.Più versioni di Ubuntu, tuttavia, di consegnarlo nelle loro emacs-chicche pacchetti.

Io uso emacs su Windows.la compilazione del modulo è bello, ma ho voluto compilare per essere più intelligenti circa la compilazione della riga di comando suggerisce. È possibile utilizzare il File di "Variabili" per specificare compile-command, ma volevo qualcosa di un po ' più intelligente di così.Così ho scritto un po ' la funzione di aiutare.Si indovina il comando di compilazione di utilizzare, per richiedere all'utente, quando l'esecuzione di compile.

Guess funzione cerca vbproj o csproj o sln file, e se trovato, si suggerisce di msbuild.Quindi cerca il file di buffer nome, e, a seconda che, suggerisce cose diverse.Un .wxs file significa che è un progetto WIX, ed è probabile che si desidera creare un file MSI, quindi, l'ipotesi logica suggerisce un comando di nmake per il MSI.Se si tratta di un Javascript module, quindi il suggerimento è quello di eseguire jslint-for-wsh.js per il panno .file js.Come ripiego, si suggerisce di nmake.

Il codice che uso simile 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 fare questo come "prima consulenza" per la funzione di compilazione, ma non riuscivo a farlo funzionare in modo soddisfacente.Così ho definito una nuova funzione, associata alla stessa combinazione di tasti ho usato per compile.

MODIFICA ora c'è "più intelligente di compilazione.el"che prende questa idea un ulteriore passo in avanti.

Sulla documentazione di ricerca:che dipende dal linguaggio di programmazione(s).

Librerie C e le chiamate di sistema sono generalmente documentati nelle pagine man.Per questo si può utilizzare M-x man.Alcune cose possono essere documentati meglio nelle pagine di informazioni;utilizzare M-x info.

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

Trovo che la maggior parte degli altri linguaggi di documentazione in formato html.Per questo, provare un browser incorporato (io uso w3m).Impostare il BROWSER variabile di ambiente per uno script wrapper intorno emacsclient -e "(w3m-goto-url-new-session \"$@\")" (su *nix), nel caso in cui qualcosa potrebbe aprire un browser e si desidera che si è aperto all'interno di emacs.

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

IMO il miglior modo per usare emacs come un ide è quello di utilizzare un la lingua del server di protocollo con emacs.Trovate tutte le informazioni su linguaggio server del sito web collegato.

Per una rapida installazione, vi esorto ad andare a questa pagina eglot .IMO eglot e fa il suo lavoro abbastanza bene.E ben si integra con auto completamenti pacchetti come società.Fornisce trovare di riferimento, e di più.

Anche per un debugger, è possibile che necessitano di specifici programmi di messa a punto specifici per le lingue.È possibile utilizzare gdb da emacs.Basta digitare M-x gdb .

Per compilare il codice, è meglio usare la shell dei comandi.Sto lavorando su questo progetto eproj.Sta andando a prendere un po ' per completare.Ma non sono le mappe comando di shell per tipo di progetto.E costruisce il progetto via shell.Vale lo stesso per eseguire il comando.Avrei bisogno un aiuto per completare questo progetto.Non è pronto per l'uso, ma se sai un po ' di elisp si può passare attraverso il codice.

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

Per il controllo di versione, non ho ancora visto nessun altro pacchetto che può competere con la potenza di magit.È specifico della git.Anche per git c'è un altro pacchetto git-timemachine, che trovo molto utile.

Oggetto di ricerca e classe di ricerca è fornito dalla lingua del server di protocollo.

Un progetto è un albero che può essere utilizzato per ide, come interfaccia con treemacs.

C'è anche un progetto di Interazione Libreria chiamata proiettile.

Per il completamento automatico, trovo società-modalità di molto utile.

Veramente emacs può essere fatta a fare nulla.

Negli ultimi anni, Clang è diventato una parte importante della Emacs supporto C++.Atila Neves avuto una discussione su CppCon 2015:"Emacs come C++ IDE"

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

  • Salto di definizione
  • Auto-completamento
  • On-the-fly evidenziazione della sintassi
  • Trovare il file nel progetto

Le diapositive possono essere trovati qui.

In Unix o X lo stile windows, non so che c'è un IDE integrato che funziona per tutto.

Per l'interazione con i debugger, solo una componente di un IDE, in considerazione realgud.L'altra cosa che trovo utili sono parser per la posizione di messaggi, in modo che se si dispone di una traccia di stack di chiamata e desidera modificare in un posto particolare nel stack di chiamate, questa interfaccia front-end si può fare.

Finora questo programma potrebbero migliorare.Ma poi si potrebbe utilizzare anche le persone che lavorano su di esso per migliorare.

Disclaimer:Io lavoro su realgud

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top