it-swarm-pt.tech

Usando o Emacs como um IDE

Atualmente, meu fluxo de trabalho com o Emacs quando estou codificando em C ou C++ envolve três janelas. O maior à direita contém o arquivo com o qual estou trabalhando. A esquerda é dividida em duas, a parte inferior é um Shell que eu uso para compilar ou fazer comandos, e o topo é frequentemente algum tipo de documentação ou arquivo README que eu quero consultar enquanto estou trabalhando. Agora eu sei que existem alguns usuários Emacs bem experientes por aí, e estou curioso para saber que outros Emacs são funcionalmente úteis se a intenção é usá-lo como um IDE completo. Especificamente, a maioria dos IDEs geralmente cumprem essas funções de alguma forma ou de outra:

  • Editor de código fonte
  • Compilador
  • Depuração
  • Pesquisa de documentação
  • Controle de versão
  • Recursos OO, como pesquisa de classe e inspetor de objetos 

Para alguns deles, é bastante óbvio como o Emacs pode se encaixar nessas funções, mas e o resto? Além disso, se um idioma específico deve ser focado, eu diria que deveria ser C++. 

Edit: Um usuário apontou que eu deveria ter sido mais específico quando disse 'e o resto'. Principalmente eu estava curioso sobre o controle de versão eficiente, bem como pesquisa de documentação. Por exemplo, no SLIME é bastante fácil fazer uma rápida pesquisa hiperespecífica em uma função LISP. Existe uma maneira rápida de procurar algo na documentação do C++ STL (se eu esqueci a sintaxe exata de hash_map , por exemplo)?

163
user7545

Você terá que ser específico sobre o que você quer dizer com "o resto". Exceto pelo inspetor de objetos (que eu conheço), o emacs faz tudo isso com bastante facilidade:

  • editor (óbvio)
  • compilador - apenas execute M-x compile e digite seu comando de compilação. A partir daí, você pode apenas M-x compile e usar o padrão. O Emacs irá capturar erros do compilador C/C++ (funciona melhor com o GCC) e ajudá-lo a navegar para linhas com avisos ou erros.
  • Depuração - da mesma forma, quando você deseja depurar, digite M-x gdb e ele criará um buffer gdb com ligações especiais
  • Pesquisa de documentação - o emacs possui excelentes ligações CScope para navegação de código. Para outras documentações: o Emacs também possui um leitor de manpages e, para todo o resto, existe a web e os livros.
  • controle de versão - há muitas ligações do Emacs para vários backends de VCS (CVS, SCCS, RCS, SVN, GIT, todos vêm à mente)

Edit: Eu percebo a minha resposta sobre pesquisa de documentação realmente pertencia a navegação de código. Aqui está mais algumas informações sobre o ponto: 

A pesquisa do Google, sem dúvida, revelará mais exemplos.

Como o segundo link mostra, procurar por funções (e qualquer outra) em outra documentação pode ser feito, mesmo que não seja suportado fora da caixa.

73
Ben Collins

Eu tenho que recomendar o Emacs Code Browser como um ambiente de estilo mais "tradicional" IDE para o emacs.

EDIT: Eu também recomendo agora Magit muito acima da interface padrão do VCS no emacs.

29
baudtack

Em vez de executar um comando make na janela do Shell, você já tentou a compilação M-x? Ele executará seu comando make, exibirá erros e, em muitos casos, será muito fácil ir para a linha de código que causou o erro se a saída incluir nomes de arquivos e números de linha.

Se você é um fã de IDEs, você também pode querer olhar para o pacote de speedbar do emacs (M-x speedbar). E, se ainda não tiver aprendido, saiba como usar tabelas de tags para navegar em seu código.

19
Bryan Oakley

Existem cantos do emacs que, uma vez descobertos, tornam você mais produtivo de maneiras que você nunca imaginou. Como outros já mencionaram, o uso de tags é uma maneira fantástica e rápida de aplicar zoom em seu código-fonte, e o uso de M-/(dabbrev-expand) geralmente faz exatamente o que você espera ao concluir um nome de variável. 

A utilização de ocorrer é útil para obter um buffer com todas as ocorrências de uma expressão regular em um buffer. Isso é muito útil ao refatorar código e procurar por fragmentos de código ou uso de variáveis, ou se você usa marcadores TODO em seus arquivos de origem e deseja visitar todos eles.

campos flush, campos sort-numeric-fields, replace-regexp e retângulo podem ser muito úteis para tirar um dump de alguma ferramenta e convertê-la em dados úteis, como um programa elisp ou uma planilha delimitada por vírgula. 

Eu escrevi uma página sobre IDE como coisas que você pode fazer com o emacs 

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

Aprender elisp é outra ótima maneira de responder por si mesmo o que mais o emacs pode fazer além do que um típico IDE pode fazer. 

Por exemplo, eu escrevi sobre escrever funções auxiliares do Perforce como culpa (escrever seus próprios significa que você pode fazê-lo se comportar exatamente como você quer) ...

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

Eu também escrevi código que dinamicamente cria comentários para uma função no ponto, que corresponde aos padrões de codificação com os quais estou trabalhando. 

Nenhum dos meus códigos elisp é particularmente grande, e a maior parte já existe nas bibliotecas, mas é realmente útil fazer com que os emacs façam coisas personalizadas que surgem durante um dia de trabalho. 

15
justinhj

Você pode encontrar uma descrição detalhada da integração do emacs & version control no my site . Eu também estou trabalhando no artigo sobre como usar o Emacs como Ambiente de Desenvolvimento para muitas linguagens - C/C++, Java, Perl, LISP/Esquema, Erlang, etc ...

10
Alex Ott

Ok, todos aqui estão dando dicas perfeitas para fazer do emacs um ótimo IDE. 

Mas qualquer um deve ter em mente que, quando você personaliza seus emacs com muita extensão (especialmente com aqueles para checagem de tipos na hora, pesquisas de definição de função, etc.) seus emacs carregam muito, muito devagar para um editor. 

Para contornar isso, eu recomendo usar o emacs em server mode

É muito simples de usar, não há necessidade de personalizar seu arquivo init. Você só precisa iniciar o emacs no modo daemon;

emacs --daemon

Isto irá criar um servidor emacs, então você pode conectá-lo a partir do terminal ou do gui. Também recomendo criar alguns aliases para facilitar a chamada. 

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

Desta forma, o emacs irá disparar ainda mais rápido que o gedit, promete.

O único problema possível aqui, se você está executando o daemon emacs do seu usuário casual, você provavelmente não pode conectar o servidor emacs como root

Então, se você precisa abrir um arquivo que tenha acesso root; use tramp em vez disso. Basta executar o seu cliente emacs com seu usuário normal e abrir arquivos como este;

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

Isso facilitou minha vida, e eu posso abrir meu pesado python personalizado IDE em milissegundos dessa maneira. Você também pode querer adicionar emacs --daemon à inicialização do seu sistema ou criar um arquivo de área de trabalho para o emacsclient. Isso é contigo. 

Mais sobre o daemon emacs e o cliente emacs podem ser encontrados no wiki;

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

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

8
Muhammet Can

Para controle de versão, existem várias coisas que você pode usar, dependendo do sistema de controle de versão que você usa. Mas algumas das funcionalidades são comuns a todas elas.

vc.el é a maneira interna de manipular o controle de versão no nível do arquivo. Tem backends para a maioria dos sistemas de controle de versão. Por exemplo, o back-end do Subversion vem com o Emacs, e existem back-ends do git e outros disponíveis de outras fontes.

O comando mais útil é C-x v v (vc-next-action) que faz a próxima ação apropriada para o arquivo que você está visitando. Isso pode significar atualizar a partir do repositório ou confirmar suas alterações, vc.el também revincula C-x C-q para check in e out arquivos se você estiver usando um sistema que precisa dele (como o RCS).

Outros comandos muito úteis são C-x v lC-x v = que mostra o log e o diff atual para o arquivo que você está usando.

Mas para produtividade real, você deve evitar usar os comandos vc.el de arquivo único, exceto para coisas simples. Existem vários pacotes que podem lhe dar uma visão geral do status de toda a sua árvore, e dar-lhe mais poder, sem mencionar a capacidade de criar commits coerentes que abrangem vários arquivos.

A maioria destes é fortemente influenciada ou baseada no original pcl-cvs/pcvs para o CVS. Existem até dois deles que vem com o Subversion, psvn.eldsvn.el. Existem pacotes para git etc.

8
dkagedal

Eu concordo que você deve aprender sobre a compilação M-x (ligar isso e M-x next-error a uma seqüência de teclas curtas).

Saiba mais sobre as ligações para o controle de versão (por exemplo, vc-diff, vc-next-action etc.)

Olhe nos registros. Você não apenas pode lembrar locais em buffers mas configurações inteiras de janelas (C-x r w - configuração de janelas para registrar).

7
HD.

Um ponto de partida (que pode ser não óbvio) para explorar os recursos VC do Emacs é M-x vc-next-action

Ele faz a "próxima operação de controle de versão lógica" no arquivo atual, dependendo do estado do arquivo e do backend VC. Portanto, se o arquivo não estiver sob controle de versão, ele será registrado, se o arquivo tiver sido alterado, as alterações serão enviadas etc. 

Demora um pouco para se acostumar, mas acho muito útil. 

A ligação de teclas padrão é C-x v v

6
Chopmo

Há um TFS.el para integração do emacs no Microsoft TFS . Ele funciona com qualquer TFS, incluindo o TFS que executa o Codeplex.com. 

Etapas básicas para configurar:

  1. Coloque tfs.el no seu caminho de carga.

  2. No seu arquivo .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. também no seu arquivo .emacs, defina as ligações de chave locais ou globais para os comandos tfs. igual a:

    (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 são todos comandos muito importantes para o desenvolvimento de C++ no Emacs (funciona muito bem com a saída do grep). Etags, tabela de tags de visita e tag de localização também são importantes. O completion.el é um dos grandes hacks não celebrados do século 20, e pode acelerar o seu hacking C++ em uma ordem de grandeza. Ah, e não vamos esquecer o edifício.

Eu ainda tenho que aprender como usar o controle de versão sem visitar um Shell, mas agora que eu estou executando commit muito mais frequentemente (com git) eu provavelmente terei que fazer isso.

3
jfm3

Eu uso o emacs no Windows. O módulo de compilação é legal, mas eu queria compilar para ser mais inteligente sobre a linha de comando de compilação que sugere. É possível usar "File Variables" para especificar compile-command , mas eu queria algo um pouco mais esperto do que isso. Então eu escrevi uma pequena função para ajudar. Ele adivinha o comando compile para usar, para Avisar o usuário, ao executar compile

A função guess procura um arquivo vbproj ou csproj ou sln e, se encontrado, sugere msbuild. Em seguida, ele analisa o nome do arquivo de buffer e, dependendo disso, sugere coisas diferentes. Um arquivo .wxs significa que é um projeto WIX, e você provavelmente quer construir um MSI, então a lógica de suposição sugere um comando nmake para o MSI. Se for um módulo Javascript, a sugestão é executar o jslint-for-wsh.js para remover o arquivo .js. Como um fallback, sugere nmake. 

O código que eu uso parece com isso:

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

Eu tentei fazer isso como "antes de conselhos" para a função de compilação, mas não consegui fazê-lo funcionar satisfatoriamente. Então, eu defini uma nova função e limito-a à mesma combinação de pressionamento de tecla que tenho usado para compile


EDIT existe agora " smarter-compile.el ", que leva essa idéia um passo adiante.

3
Cheeso

Você também pode encontrar tabbar useful. Ele emula o único comportamento que perdi ao passar do Eclipse para o Emacs. Vinculado a "," e "." para mover para a barra de abas anterior e seguinte, ele o revive de trocar o buffer por Ctrl-xb o tempo todo.

Infelizmente, a página da Web mencionada não fornece a versão correta para download. A maioria das versões do Ubuntu, no entanto, entregam em seus pacotes emacs-goodies.

3
wr.

Eu sei que este é um post muito antigo. Mas esta questão é válida para iniciantes do emacs.

No IMO, a melhor maneira de usar o emacs como ide é usar um protocolo language server com o emacs. Você pode encontrar todas as informações sobre servidores de idiomas no site vinculado. 

Para uma configuração rápida, peço-lhe para ir a esta página eglot . O eglot da IMO faz o trabalho muito bem. Integra-se bem com pacotes de conclusão automática como empresa. Fornece referência de referência e mais. 

Também para um depurador, você pode precisar de depuradores específicos para idiomas específicos. Você pode usar o gdb no emacs. Apenas digite M-x gdb

Para compilar seu código, é melhor usar os comandos do Shell. Eu estou trabalhando neste projeto eproj . Vai demorar um pouco para completá-lo. Mas tudo o que faz é mapear o comando Shell para o tipo de projeto. E constrói seu projeto via Shell. Ele faz o mesmo para executar o comando. Eu posso precisar de ajuda para completar este projeto. Não está pronto para uso, mas se você souber um pouco de elisp, você pode passar pelo código. 

Além disso, é sempre melhor usar o comando de compilação do emacs.

Para controle de versão, eu ainda não vi nenhum outro pacote que possa igualar o poder de magit . É específico para o git. Também para o git existe outro pacote git-timemachine, que eu acho muito útil.

A pesquisa de objetos e a pesquisa de classes são fornecidas pelo protocolo do servidor de idiomas. 

Uma árvore de projeto pode ser usada para uma interface ide com treemacs .

Há também uma biblioteca de interação do projeto chamada projétil .

Para a conclusão automática, acho modo de empresa muito útil. 

Verdadeiramente o emacs pode ser feito para fazer qualquer coisa.

2
sidharth arya

Na pesquisa de documentação: isso depende da (s) sua (s) linguagem (s) de programação.

Bibliotecas C e chamadas do sistema são normalmente documentadas em páginas man. Para isso você pode usar M-x man. Algumas coisas podem ser melhor documentadas em páginas de informações; use M-x info.

Para o próprio elisp, use C-h f. Para python, use >>> help(<function, class, module>) no interpretador.

Acho que a maioria das outras linguagens oferecem documentação em formato html. Para isso, tente um navegador embutido (eu uso o w3m). Defina sua variável de ambiente BROWSER para um script wrapper em torno de emacsclient -e "(w3m-goto-url-new-session \"[email protected]\")" (no * nix), caso algo possa abrir um navegador e você o queira abrir dentro do emacs.

2
Jonas Kölker

Nos últimos anos, o Clang tornou-se uma parte importante do suporte do Emacs C++. Atila Neves teve uma palestra na CppCon 2015: "Emacs como uma IDE C++"

É uma palestra de 16 minutos, onde ele mostra soluções para os seguintes tópicos:

  • Ir para a definição
  • Preenchimento automático
  • Realce de sintaxe on-the-fly
  • Encontre o arquivo no projeto

Slides podem ser encontrados aqui .

1
Philipp Claßen

No estilo Unix ou X windows, não sei se existe um IDE integrado que funcione para tudo. 

Para interagir com depuradores, apenas um componente de um IDE, considere realgud . A outra coisa que eu acho útil são os analisadores de mensagens de localização, de modo que se você tiver um rastreamento de pilha de chamadas e desejar editar em um local específico na pilha de chamadas, essa interface de front-end poderá fazer isso. 

De longe, este programa poderia usar melhorias. Mas também pode usar pessoas trabalhando para melhorá-lo. 

Disclaimer: Eu trabalho em realgud

0
rocky