Utiliser Emacs comme un IDE

Actuellement, mon flux de travail avec Emacs lorsque je codifie en C ou C ++ implique trois fenêtres. Le plus grand sur la droite contient le fichier avec lequel je travaille. La gauche est divisée en deux, le bas étant un shell que j'utilise pour taper dans compiler ou faire des commandes, et le haut est souvent une sorte de documentation ou de fichier README que je veux consulter pendant que je travaille. Maintenant, je sais qu'il y a quelques utilisateurs assez experts d'Emacs, et je suis curieux de savoir quels autres Emacs sont fonctionnellement utiles si l'intention est de les utiliser comme un IDE complet. Plus précisément, la plupart des IDE remplissent généralement ces fonctions sous une forme ou une autre:

• Éditeur de code source
• Compilateur
• Débogage
• Recherche de documentation
• Contrôle de version
• Fonctionnalités OO telles que la recherche de classe et l'inspecteur d'objets

Pour certains d'entre eux, il est assez évident comment Emacs peut intégrer ces fonctions, mais qu'en est-il du reste? De plus, si un langage spécifique doit être ciblé, je dirais qu'il devrait être C ++.

Edit: Un utilisateur a fait remarquer que j'aurais dû être plus précis quand j'ai dit «qu'en est-il du reste». J'étais surtout curieux de savoir si le contrôle de version était efficace, ainsi que la recherche de documentation. Par exemple, dans SLIME, il est assez facile de faire une recherche rapide d'hyperspec sur une fonction Lisp. Existe-t-il un moyen rapide de rechercher quelque chose dans la documentation C ++ STL (si j'ai oublié la syntaxe exacte de hash_map , par exemple)?

Vous devrez être précis sur ce que vous entendez par «le reste». À l'exception de l'inspecteur d'objets (dont je suis conscient), emacs fait tout ce qui précède assez facilement:

• éditeur (évident)
• compilateur - lancez simplement M-x compileet entrez votre commande de compilation. À partir de là, vous pouvez simplement M-x compileet utiliser la valeur par défaut. Emacs capturera les erreurs du compilateur C / C ++ (fonctionne mieux avec GCC) et vous aidera à naviguer vers les lignes contenant des avertissements ou des erreurs.
• Débogage - de même, lorsque vous souhaitez déboguer, tapez M-x gdbet cela créera un tampon gdb avec des liaisons spéciales
• Recherche de documentation - emacs a d'excellentes liaisons CScope pour la navigation dans le code. Pour toute autre documentation: Emacs a également un lecteur de pages de manuel, et pour tout le reste, il y a le Web et les livres.
• contrôle de version - il existe de nombreuses liaisons Emacs pour divers backends VCS (CVS, SCCS, RCS, SVN, GIT viennent à l'esprit)

Edit: Je réalise que ma réponse sur la recherche de documentation concerne vraiment la navigation dans le code. Voici quelques informations plus précises:

• Recherche de pages de manuel, de manuels d'information et de documentation Elisp à partir d'emacs
• Recherche de la documentation Python depuis Emacs .

La recherche sur Google révélera sans aucun doute d'autres exemples.

Comme le montre le deuxième lien, la recherche de fonctions (et autres) dans une autre documentation peut être effectuée, même si elles ne sont pas prises en charge par défaut.

Je dois recommander Emacs Code Browser comme environnement de style IDE plus "traditionnel" pour emacs.

EDIT : Je recommande également vivement Magit par rapport à l'interface VCS standard dans emacs.

Au lieu d'exécuter une commande make dans la fenêtre shell, avez-vous essayé Mx compile? Il exécutera votre commande make, affichera les erreurs et, dans de nombreux cas, rendra très facile le passage à la ligne de code qui a causé l'erreur si la sortie comprend des noms de fichiers et des numéros de ligne.

Si vous êtes un fan des IDE, vous voudrez peut-être aussi regarder le package speedbar d'emacs (Mx speedbar). Et, si vous ne l'avez pas déjà fait, découvrez comment utiliser les tables de balises pour parcourir votre code.

Il y a des coins d'Emacs qui, une fois découverts, vous rendent plus productif d'une manière que vous n'avez jamais imaginée. Comme d'autres l'ont mentionné, l'utilisation de balises est un moyen fantastique et rapide de zoomer sur votre code source et l'utilisation de M- / (dabbrev-expand) fait souvent exactement ce que vous attendez lorsque vous remplissez un nom de variable.

L'utilisation de occur est utile pour obtenir un tampon avec toutes les occurrences d'une expression régulière dans un tampon. C'est vraiment pratique pour refactoriser du code et rechercher des fragments de code ou des utilisations de variables, ou si vous utilisez des marqueurs TODO dans vos fichiers sources et que vous souhaitez tous les visiter.

Les fonctions flush-lines, sort-numeric-fields, replace-regexp et rectangle peuvent être vraiment utiles pour effectuer un vidage d'un outil et le convertir en données utiles telles qu'un programme elisp ou une feuille de calcul délimitée par des virgules.

J'ai écrit une page sur l'IDE comme ce que vous pouvez faire avec emacs

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

Apprendre elisp est un autre excellent moyen de répondre par vous-même à ce qu'emacs peut faire au-delà de ce qu'un IDE typique peut faire.

Par exemple, j'ai blogué sur l'écriture de fonctions d'assistance Perforce comme blame (écrire votre propre signifie que vous pouvez le faire se comporter exactement comme vous le souhaitez) ...

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

J'ai également écrit du code qui crée dynamiquement des commentaires pour une fonction à un moment donné, qui correspond aux normes de codage avec lesquelles je travaille.

Aucun de mes codes elisp n'est particulièrement génial, et la plupart d'entre eux existent déjà dans des bibliothèques, mais c'est vraiment utile de pouvoir faire en sorte qu'emacs fasse des choses personnalisées qui surviennent juste pendant une journée de travail.

Vous pouvez trouver une description détaillée de l'intégration d'emacs et du contrôle de version sur mon site . Je travaille également sur un article sur l'utilisation d'Emacs comme environnement de développement pour de nombreux langages - C / C ++, Java, Perl, Lisp / Scheme, Erlang, etc ...

Pour le contrôle de version, vous pouvez utiliser plusieurs éléments, selon le système de contrôle de version que vous utilisez. Mais certaines fonctionnalités sont communes à tous.

vc.el est le moyen intégré de gérer le contrôle de version au niveau du fichier. Il a des backends pour la plupart des systèmes de contrôle de version. Par exemple, le backend Subversion est livré avec Emacs, et il existe des backends git et d'autres disponibles à partir d'autres sources.

La commande la plus utile est Cx vv (vc-next-action) qui effectue l'action suivante appropriée pour le fichier que vous visitez. Cela peut signifier une mise à jour à partir du référentiel ou la validation de vos modifications, vc.el relie également Cx Cq pour archiver et extraire les fichiers si vous utilisez un système qui en a besoin (comme RCS).

D'autres commandes très utiles sont Cx vl et Cx v = qui vous montrent le journal et la différence actuelle pour le fichier que vous utilisez.

Mais pour une vraie productivité, vous devriez éviter d'utiliser les commandes vc.el à fichier unique autrement que pour des choses simples. Il existe plusieurs packages qui peuvent vous donner un aperçu de l'état de l'ensemble de votre arbre, et vous donner plus de puissance, sans parler de la possibilité de créer des commits cohérents couvrant plusieurs fichiers.

La plupart d'entre eux sont fortement influencés ou basés sur les pcl-cvs / pcvs originaux pour CVS. Il y a même deux d'entre eux qui vient avec la subversion, psvn.el et dsvn.el . Il existe des packages pour git, etc.

D'accord, tout le monde ici donne des conseils parfaits pour faire d'emacs un excellent IDE.

Mais tout le monde devrait garder à l'esprit que, lorsque vous personnalisez vos emacs avec beaucoup d'extensions (en particulier avec celles pour la vérification de type à la volée, les recherches de définitions de fonctions, etc.), vos emacs se chargeront très, très lentement pour un éditeur.

Pour contourner ce problème, je recommande vivement d'utiliser emacs dans server mode.

Il est assez simple à utiliser, pas besoin de personnaliser votre fichier init. Il vous suffit de démarrer emacs en mode démon;

emacs --daemon

Cela créera un serveur emacs, puis vous pourrez le connecter soit depuis le terminal, soit depuis l'interface graphique. Je recommanderais également de créer des alias pour faciliter l'appel.

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

De cette façon, emacs se lancera encore plus vite que gedit, promis.

Le seul problème possible ici, si vous exécutez le démon emacs depuis votre utilisateur occasionnel, vous ne pouvez probablement pas connecter le serveur emacs en tant que root.

Donc, si vous devez ouvrir un fichier qui a un accès root; utiliser à la trampplace. Exécutez simplement votre client emacs avec votre utilisateur normal et ouvrez des fichiers comme celui-ci;

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

Cela m'a simplifié la vie, je peux ouvrir mon IDE python personnalisé lourd en quelques millisecondes de cette façon. Vous pouvez également ajouter emacs --daemon au démarrage de votre système ou créer un fichier de bureau pour emacsclient. C'est à toi de voir.

Vous trouverez plus d'informations sur le démon emacs et le client emacs sur wiki;

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

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

Je suis d'accord que vous devriez en savoir plus sur la compilation Mx (liez cela et l'erreur suivante Mx à une courte séquence de touches).

Découvrez les liaisons pour le contrôle de version (par exemple vc-diff, vc-next-action, etc.)

Regardez dans les registres. Vous pouvez non seulement vous souvenir des emplacements dans les tampons, mais des configurations de fenêtres entières (Cx rw - window-configuration-to-register).

Un point de départ (qui peut ne pas être évident) pour explorer les fonctionnalités VC d'Emacs est Mx vc-next-action .

Il effectue la "prochaine opération de contrôle de version logique" sur le fichier actuel, en fonction de l'état du fichier et du backend VC. Donc, si le fichier n'est pas sous contrôle de version, il l'enregistre, si le fichier a été modifié, les modifications sont soumises, etc.

Il faut un peu de temps pour s'y habituer, mais je trouve cela très utile.

La liaison de touches par défaut est Cx vv

Il existe un TFS.el pour l'intégration emacs dans Microsoft TFS . Il fonctionne avec n'importe quel TFS, y compris le TFS qui exécute Codeplex.com.

Étapes de base pour la configuration:

1. Placez tfs.el dans votre chemin de chargement.

2. Dans votre fichier .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. également dans votre fichier .emacs, définissez les raccourcis clavier locaux ou globaux pour les commandes tfs. ainsi:

   (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 et previous-error sont toutes des commandes assez importantes pour le développement C ++ dans Emacs (fonctionne également très bien sur la sortie grep). Les étiquettes, les tables de balises de visite et les balises de recherche sont également importantes. complete.el est l'un des grands hacks méconnus du 20e siècle et peut accélérer votre piratage C ++ d'un ordre de grandeur. Oh et n'oublions pas ediff.

Je n'ai pas encore appris à utiliser le contrôle de version sans visiter un shell, mais maintenant que j'exécute des commits beaucoup plus fréquemment (avec git), je devrai probablement le faire.

Vous pouvez également trouver la barre d'onglets utile. Il émule le seul comportement que j'ai manqué lors du passage d'Eclipse à Emacs. Lié à "," et "." pour passer à la barre d'onglets précédente et suivante, il vous revit de changer le tampon par Ctrl-x b tout le temps.

Malheureusement, la page Web mentionnée ne fournit pas la bonne version à télécharger. Cependant, la plupart des versions d'Ubuntu le livrent dans leurs packages emacs-goodies.

J'utilise emacs sous Windows. le module de compilation est sympa, mais je voulais que la compilation soit plus intelligente sur la ligne de commande de compilation qu'il suggère. Il est possible d'utiliser "File Variables" pour spécifiercompile-command , mais je voulais quelque chose d'un peu plus intelligent que cela. J'ai donc écrit une petite fonction pour aider. Il devine la commande de compilation à utiliser, pour inviter l'utilisateur avec, lors de l'exécution compile.

La fonction guess recherche un fichier vbproj ou csproj ou sln, et s'il est trouvé, elle suggère msbuild. Ensuite, il regarde le nom du fichier tampon et, en fonction de cela, suggère différentes choses. Un fichier .wxs signifie qu'il s'agit d'un projet WIX et que vous souhaitez probablement créer un MSI, de sorte que la logique de supposition suggère une commande nmake pour le MSI. S'il s'agit d'un module Javascript, alors la suggestion est d'exécuter jslint-for-wsh.js pour lint le fichier .js. Comme solution de secours, il suggère nmake.

Le code que j'utilise ressemble à ceci:

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

J'ai essayé de faire cela comme "avant conseil" pour la fonction de compilation mais je n'ai pas pu la faire fonctionner de manière satisfaisante. J'ai donc défini une nouvelle fonction et l'ai liée à la même combinaison de touches que j'utilisais compile.

EDIT il y a maintenant " smarter-compile.el " qui va encore plus loin dans cette idée.

Sur la recherche de documentation: cela dépend de votre (vos) langage (s) de programmation.

Les bibliothèques C et les appels système sont généralement documentés dans les pages de manuel. Pour cela, vous pouvez utiliser M-x man. Certaines choses peuvent être mieux documentées dans les pages d'informations; utiliser M-x info.

Pour elisp lui-même, utilisez C-h f. Pour python, utilisez >>> help(<function, class, module>)dans l'interpréteur.

Je trouve que la plupart des autres langues proposent de la documentation sous forme html. Pour cela, essayez un navigateur intégré (j'utilise w3m). Définissez votreBROWSER variable d'environnement sur un script wrapper autour emacsclient -e "(w3m-goto-url-new-session \"$@\")"(sur * nix), au cas où quelque chose pourrait ouvrir un navigateur et que vous voudriez qu'il soit ouvert dans emacs.

Je sais que c'est un très vieux message. Mais cette question est valable pour les débutants emacs.

OMI, la meilleure façon d'utiliser emacs comme ide est d'utiliser un protocole de serveur de langage avec emacs. Vous pouvez trouver toutes les informations sur les serveurs linguistiques sur le site Web lié.

Pour une configuration rapide, je vous conseille vivement de vous rendre sur cette page eglot . IMO eglot fait assez bien son travail. Il s'intègre bien avec les packages de complétions automatiques comme Company. Fournit des références de recherche, et plus encore.

Pour un débogueur, vous pouvez également avoir besoin de débogueurs spécifiques pour des langues spécifiques. Vous pouvez utiliser gdb depuis emacs. Tapez simplement M-x gdb.

Pour compiler votre code, il est préférable d'utiliser des commandes shell. Je travaille sur ce projet eproj . Ça va prendre un certain temps pour le terminer. Mais tout ce qu'il fait, c'est mapper la commande shell sur le type de projet. Et construit votre projet via shell. Il fait de même pour exécuter la commande. J'ai peut-être besoin d'aide pour terminer ce projet. Il n'est pas prêt à être utilisé, mais si vous connaissez un peu elisp, vous pouvez parcourir le code.

Cela mis à part, il est toujours préférable d'utiliser la commande emacs compile.

Pour le contrôle de version, je n'ai encore vu aucun autre package qui puisse égaler la puissance de magit . C'est spécifique à git. Pour git, il existe également un autre paquet git-timemachine, que je trouve très utile.

La recherche d'objets et la recherche de classes sont fournies par le protocole du serveur de langage.

Une arborescence de projet peut être utilisée pour une interface de type ide avec les treemacs .

Il existe également une bibliothèque d'interaction de projet appelée projectile .

Pour la complétion automatique, je trouve le mode entreprise très utile.

Vraiment, emacs peut faire n'importe quoi.

Ces dernières années, Clang est devenu une partie importante du support Emacs C ++. Atila Neves a eu une conférence sur CppCon 2015: "Emacs en tant qu'IDE C ++"

C'est une conférence de 16 minutes, où il montre des solutions pour les sujets suivants:

• Aller à la définition
• Auto-complétion
• Mise en évidence de la syntaxe à la volée
• Rechercher un fichier dans le projet

Des diapositives peuvent être trouvées ici .

Dans le style Windows Unix ou X, je ne sais pas s'il existe un IDE intégré qui fonctionne pour tout.

Pour interagir avec les débogueurs, un seul composant d'un IDE, considérez realgud . L'autre chose qu'il a que je trouve utile sont les analyseurs pour les messages de localisation, de sorte que si vous avez une trace de pile d'appels et que vous voulez éditer à un endroit particulier dans la pile d'appels, cette interface frontale peut le faire.

De loin, ce programme pourrait être amélioré. Mais alors, il pourrait également utiliser des personnes qui y travaillent pour l'améliorer.

Avertissement: je travaille sur realgud

Essayez le mode lsp. Vous pouvez maintenant utiliser d'autres fonctionnalités IDE dans emacs pour vous connecter au serveur. Recherchez plus d'informations: lsp-mode