Question

Actuellement, mon flux de travail avec Emacs lorsque je code en C ou C ++ implique trois fenêtres. Le plus grand à 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 des commandes compile ou make, et le haut est souvent une sorte de documentation ou un fichier README que je souhaite consulter pendant que je travaille. Maintenant, je sais qu’il existe de bons utilisateurs d’Emacs, et je suis curieux de savoir quels autres Emacs sont utiles d’un point de vue fonctionnel 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
  • Consultation de la documentation
  • Contrôle de version
  • Fonctions OO telles que la recherche de classe et l'inspecteur d'objets

Pour certains d'entre eux, il est assez évident de voir comment Emacs peut s’adapter à ces fonctions, mais qu’en est-il du reste? De plus, si un langage spécifique doit être ciblé, je dirais que ce devrait être le C ++.

Modifier: Un utilisateur a fait remarquer que j'aurais dû être plus précis lorsque j'ai dit "Et le reste". La plupart du temps, j'étais curieux du contrôle de version efficace, ainsi que de la recherche de documentation. Par exemple, dans SLIME, il est assez facile de faire une recherche hyperspec rapide sur une fonction Lisp. Existe-t-il un moyen rapide de rechercher quelque chose dans la documentation C ++ STL (si j'avais oublié la syntaxe exacte de hash_map , par exemple)?

Était-ce utile?

La solution

Vous devrez préciser ce que vous entendez par & "; le reste &"; À l'exception de l'inspecteur d'objets (que je & Connais très bien), emacs fait tout ce qui précède assez facilement:

  • éditeur (évident)
  • compilateur - exécutez simplement M-x compile et entrez votre commande de compilation. À partir de là, vous pouvez simplement M-x gdb utiliser la valeur par défaut. Emacs capturera les erreurs du compilateur C / C ++ (fonctionne mieux avec GCC) et vous aidera à naviguer dans les lignes contenant des avertissements ou des erreurs.
  • Débogage - de la même manière, lorsque vous souhaitez déboguer, saisissez <=> pour créer un tampon gdb avec des liaisons spéciales
  • Consultation de la documentation - emacs dispose d'excellentes liaisons CScope pour la navigation dans le code. Pour les autres documentations: 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 y a beaucoup de liaisons Emacs pour différents backends VCS (CVS, SCCS, RCS, SVN, GIT), cela vous vient à l'esprit.

Edit: Je réalise que ma réponse à propos de la recherche de documentation concernait réellement la navigation dans le code. Voici quelques informations supplémentaires utiles:

La

recherche sur Google révélera sans doute d’autres exemples.

Comme le montre le deuxième lien, il est possible de rechercher des fonctions (et autres) dans une autre documentation, même si elles ne sont pas prises en charge immédiatement.

Autres conseils

Je dois recommander le Emacs Code Browser en tant que plus & "traditionnel &"; Environnement de style IDE pour emacs.

MODIFIER : je recommande également désormais Magit de dépasser les standards Interface VCS dans emacs.

Au lieu d’exécuter une commande make dans la fenêtre du shell, avez-vous essayé de compiler M-x? Il lancera votre commande make, affichera des erreurs et, dans de nombreux cas, vous permettra de passer facilement à la ligne de code à l'origine de l'erreur si la sortie comporte des noms de fichier et des numéros de ligne.

Si vous êtes un fan des IDE, vous voudrez peut-être aussi regarder le paquet speedbar d’emacs (speedbar M-x). Et, si vous ne l'avez pas déjà fait, découvrez comment utiliser les tableaux de balises pour naviguer dans votre code.

Certains coins d’emacs qu’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 du nom de variable.

Il est utile d’obtenir un tampon avec toutes les occurrences d’une expression régulière dans un tampon. C’est vraiment pratique lorsque vous refactorisez du code et recherchez des fragments de code ou des utilisations de variables, ou si vous utilisez des marqueurs TODO dans vos fichiers source et que vous souhaitez tous les visiter.

Les fonctions flush-lines, sort-numeric-fields, replace-regexp et rectangle peuvent être très utiles pour extraire un dump 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 IDE comme tout ce que vous pouvez faire avec emacs

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

Apprendre à utiliser elisp est un autre excellent moyen de déterminer par vous-même ce qu’emacs peut faire au-delà de ce qu’une IDE classique peut faire.

Par exemple, j’ai écrit sur des blogs sur l’écriture de fonctions d’aide de Perforce comme blâmer (écrire vous-même 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 un code qui crée de manière dynamique 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 les bibliothèques, mais il est très utile de pouvoir faire en sorte que emacs personnalise des éléments personnalisés lors d’une journée de travail.

Vous pouvez trouver une description détaillée de emacs & amp; Intégration du contrôle de version sur mon site . Je travaille également sur un article sur l’utilisation d’Emacs en tant qu’environnement de développement pour de nombreuses langues - C / C ++, Java, Perl, Lisp / Scheme, Erlang, etc.

Pour le contrôle de version, vous pouvez utiliser plusieurs éléments, en fonction du 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 des fichiers. Il a 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 sources disponibles.

La commande la plus utile est C-x v (vc-next-action), qui effectue l'action suivante appropriée pour le fichier que vous visitez. Cela peut signifier mettre à jour à partir du référentiel ou valider vos modifications, vc.el rebinds également C-x C-q pour archiver et sortir des fichiers si vous utilisez un système qui en a besoin (comme RCS).

Les autres commandes très utiles sont C-x v l et C-x v = , qui affichent le journal et le diff actuel du fichier que vous utilisez.

Toutefois, pour une productivité réelle, évitez d’utiliser les commandes vc.el à fichier unique autres que pour des tâches simples. Plusieurs packages peuvent vous donner un aperçu de l’état de l’ensemble de votre arborescence, vous donner plus de pouvoir, sans oublier la possibilité de créer des validations cohérentes couvrant plusieurs fichiers.

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

D'accord, tout le monde ici donne des astuces parfaites pour faire d'Emacs un excellent IDE.

Mais tout le monde devrait garder à l’esprit que, lorsque vous personnalisez votre emacs avec beaucoup d’extension (notamment avec ceux pour la vérification de type à la volée, les recherches de définition de fonction, etc.), votre emacs se chargera très, très lentement pour un éditeur. .

Pour remédier à ce problème, je vous recommande vivement d’utiliser emacs dans server mode.

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

emacs --daemon

Ceci créera un serveur emacs, vous pourrez ensuite le connecter depuis un terminal ou depuis une interface graphique. Je vous recommande également de créer des alias pour faciliter les appels. 

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

Ainsi, emacs se lancera encore plus vite que gedit, promis.

Le seul problème possible ici, si vous utilisez le démon emacs à partir de votre utilisateur occasionnel, vous ne pourrez probablement pas vous connecter au serveur emacs en tant que root.

Donc, si vous devez ouvrir un fichier avec un accès root; utilisez tramp à la place. Il suffit d’exécuter votre client emacs avec votre utilisateur normal et d’ouvrir 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 me simplifie la vie, je peux ouvrir mon IDE personnalisé en python lourd en 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 le site wiki;

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

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

Je conviens que vous devriez en savoir plus sur la compilation M-x (lier cela et M-x next-error à une courte séquence de touches).

En savoir plus sur les liaisons pour le contrôle de version (par exemple, vc-diff, vc-next-action, etc.)

Regardez dans les registres. Vous pouvez non seulement mémoriser des emplacements dans des mémoires tampons, mais également des configurations de fenêtres entières (C-x r w - configuration de fenêtre à enregistrer).

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

Il effectue l'opération & "Prochaine opération de contrôle de version logique &"; sur le fichier en cours, 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.

Cela prend un peu de temps pour s’y habituer, mais je le trouve très utile.

La liaison de clé par défaut est C-x v v

.

Il existe un TFS.el pour l'intégration emacs dans Microsoft TFS . Il fonctionne avec n’importe quel TFS, y compris celui 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 des combinaisons de touches locales ou globales pour les commandes tfs. comme si: 

    (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 très bien aussi avec les sorties grep). Les étiquettes, visit-tags-table et find-tag sont également importantes. Achèvement.el est l’un des grands fléaux inconnus du 20ème 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 beaucoup plus souvent (avec git), je devrai le faire.

Vous pouvez également trouver la barre de tabulation utile. Il émule le seul comportement que j'ai raté lors du passage d'Eclipse à Emacs. Relié à & Quot; & Quot; et ". " pour passer à la barre de tabulation précédente et suivante, cela vous évite de changer de tampon avec Ctrl-x b tout le temps.

Malheureusement, la page Web mentionnée ne fournit pas la version correcte à télécharger. Cependant, la plupart des versions d’Ubuntu le fournissent dans leurs paquets emacs-goodies.

J'utilise emacs sous Windows. le module de compilation est bien, mais je voulais que la compilation soit plus intelligente sur la ligne de commande de compilation suggérée. Il est possible d'utiliser < !> quot; Fichier Variables " pour spécifier compile-command , mais je voulais quelque chose d'un peu plus intelligent que cela. J'ai donc écrit une petite fonction pour aider. Il suppose que la commande de compilation à utiliser, invite l'utilisateur à utiliser, lors de l'exécution de compile.

La fonction suppose que vous cherchez un fichier vbproj, csproj ou sln, et si elle est trouvée, elle suggère msbuild. Ensuite, il examine 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 fichier MSI. La logique de devinette suggère donc une commande nmake pour le fichier MSI. Si c'est un module Javascript, alors la suggestion est d'exécuter jslint-for-wsh.js pour lint le fichier .js. Comme solution de rechange, cela 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 le faire en tant que & avant conseil & avant; pour la fonction de compilation, mais ne pouvait pas le 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'ai utilisée pour <=>.

  

MODIFIER , il existe maintenant & "; el " qui va encore plus loin dans cette idée.

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

Les bibliothèques C et les appels système sont généralement décrits dans les pages de manuel. Pour cela, vous pouvez utiliser M-x man. Certaines choses peuvent être mieux documentées dans les pages d’information; utilisez 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 une documentation au format HTML. Pour cela, essayez un navigateur intégré (j'utilise w3m). Définissez votre BROWSER variable d’environnement sur un script wrapper autour de emacsclient -e "(w3m-goto-url-new-session \"$@\")" (sur * nix), au cas où un navigateur pourrait s’ouvrir et que vous souhaitez l’ouvrir dans emacs.

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

IMO, le meilleur moyen d'utiliser emacs en tant qu'idéal est d'utiliser un protocole de serveur de langues avec emacs. Vous pouvez trouver toutes les informations sur les serveurs de langues sur le site Web lié.

Pour une configuration rapide, je vous prie instamment de vous rendre sur cette page eglot . IMO eglot fait son travail plutôt bien. Il s'intègre bien aux paquets de complétions automatiques comme la société. Fournit une référence de recherche, et plus encore.

Pour un débogueur également, vous aurez peut-être besoin de débogueurs spécifiques pour des langues spécifiques. Vous pouvez utiliser gdb depuis emacs. Il suffit de taper 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 du temps pour le terminer. Mais tout ce qu’il fait est de mapper la commande shell au type de projet. Et construit votre projet via shell. Il en va de même pour exécuter la commande. J'ai peut-être besoin d'aide pour mener à bien ce projet. Ce n'est pas prêt à l'emploi, mais si vous connaissez un peu d'Elisp, vous pouvez consulter le code.

Cela dit, il est toujours préférable d'utiliser la commande de compilation emacs.

Pour le contrôle de version, je n'ai encore vu aucun autre package pouvant rivaliser avec la puissance de magit . C'est spécifique à git. Aussi pour git il y a un autre paquet git-timemachine, que je trouve très utile.

La recherche d'objet et de classe est fournie par le protocole du serveur de langage.

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

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

Pour la saisie automatique, le mode entreprise est 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 donné une conférence sur CppCon 2015: & "; Emacs en tant qu'EDI C ++ &";

C’est un entretien de 16 minutes au cours duquel il présente des solutions aux sujets suivants:

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

Vous pouvez trouver des diapositives ici .

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

Pour interagir avec les débogueurs, l'un des composants d'un IDE, pensez à realgud . Les analyseurs syntaxiques pour les messages de localisation constituent une autre chose que je trouve utile. Ainsi, si vous avez une trace de pile d’appel et souhaitez modifier à un endroit particulier de la pile d’appel, cette interface frontale pourra le faire.

De loin, ce programme pourrait être amélioré. Mais alors, il pourrait aussi faire appel à des personnes qui travaillent dessus pour l’améliorer.

Avertissement: je travaille sur realgud

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top