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 digitar compilar ou criar comandos, e a parte superior geralmente é algum tipo de documentação ou arquivo LEIA-ME que eu quero consultar enquanto estiver trabalhando. Agora eu sei que existem alguns usuários bastante experientes do Emacs por aí, e estou curioso para saber como outros Emacs funcionalmente são úteis se a intenção é usá-lo como um IDE completo. Especificamente, a maioria dos IDEs geralmente cumpre essas funções de uma 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 precisar ser focado, eu diria que deve ser C ++.

Edit: Um usuário apontou que eu deveria ter sido mais específico quando disse 'e quanto ao resto'. Fiquei curioso principalmente sobre o controle de versão eficiente, bem como a pesquisa de documentação. Por exemplo, no SLIME, é bastante fácil fazer uma pesquisa rápida de hiperespecificação 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 do hash_map , por exemplo)?

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 - basta executar M-x compilee inserir seu comando de compilação. A partir daí, você pode apenas M-x compilee usar o padrão. O Emacs captura os erros do compilador C / C ++ (funciona melhor com o GCC) e ajuda a navegar para as linhas com avisos ou erros.
• Depuração - da mesma forma, quando você quiser depurar, digite M-x gdbe ele criará um buffer gdb com ligações especiais
• Pesquisa de documentação - o emacs possui excelentes ligações do CScope para navegação de código. Para outra documentação: o Emacs também possui um leitor de páginas de manual e, para todo o resto, há a web e os livros.
• controle de versão - existem muitas ligações do Emacs para vários back-end VCS (CVS, SCCS, RCS, SVN, GIT todos vêm à mente)

Editar: percebo que minha resposta sobre a pesquisa de documentação realmente se refere à navegação de código. Aqui estão algumas informações mais detalhadas:

• Procurando páginas de manual, manuais de informações e documentação do Elisp no emacs
• Pesquisando a documentação do Python no Emacs .

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

Como o segundo link mostra, a busca de funções (e o que quer que seja) em outra documentação pode ser feita, mesmo que não seja suportada imediatamente.

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

EDIT : Agora também recomendo o Magit altamente através da interface VCS padrão no emacs.

Em vez de executar um comando make na janela do shell, você tentou compilar o Mx? Ele executará seu comando make, exibirá erros e, em muitos casos, facilitará muito o salto para a linha de código que causou o erro se a saída incluir nomes de arquivos e números de linhas.

Se você é fã de IDEs, também pode querer dar uma olhada no pacote speedbar do emacs (Mx speedbar). E, se você ainda não o fez, saiba como usar as tabelas de tags para navegar no seu código.

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

O uso de ocorrem é útil para obter um buffer com todas as ocorrências de uma expressão regular em um buffer. Isso é realmente útil ao refatorar o código e procurar fragmentos de código ou usos de variáveis, ou se você usa marcadores TODO nos arquivos de origem e deseja visitá-los todos.

as funções de linhas de descarga, campos de classificação numérica, substituir-regexp e retângulo podem ser realmente úteis para retirar um dump de alguma ferramenta e convertê-lo 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 IDE típico pode fazer.

Por exemplo, escrevi em um blog sobre escrever funções auxiliares do Perforce, como culpar (escrever seus próprios meios significa que você pode fazê-lo se comportar exatamente como deseja) ...

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

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

Nenhum dos meus códigos elisp é particularmente excelente, e a maioria já existe em bibliotecas, mas é realmente útil poder fazer o emacs fazer coisas personalizadas que surgem durante um dia útil.

Você pode encontrar uma descrição detalhada da integração com o emacs e controle de versão no meu site . Também estou trabalhando no artigo sobre o uso do Emacs como ambiente de desenvolvimento para muitas linguagens - C / C ++, Java, Perl, Lisp / Scheme, Erlang, etc ...

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 todos eles.

O vc.el é a maneira integrada de lidar com o controle de versão no nível do arquivo. Possui back-end 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 git e outros disponíveis de outras fontes.

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

Outros comandos muito úteis são Cx vl e Cx v = que mostram o registro e o diff atual para o arquivo que você está usando.

Mas, para obter produtividade real, evite usar os comandos vc.el de arquivo único, exceto para coisas simples. Existem vários pacotes que podem fornecer uma visão geral do status de toda a árvore, além de oferecer mais poder, além de mencionar a capacidade de criar confirmações coerentes em vários arquivos.

A maioria deles é fortemente influenciada ou baseada nos pcl-cvs / pcvs originais do CVS. Há mesmo dois deles que vem com a subversão, psvn.el e dsvn.el . Existem pacotes para o git etc.

Ok, todo mundo aqui está dando dicas perfeitas para tornar o emacs um ótimo IDE.

Mas qualquer um deve ter em mente que, quando você personaliza o seu emacs com várias extensões (especialmente as para verificação de tipo em tempo real, pesquisas de definição de função etc.), o seu emacs carrega muito, muito lentamente para um editor.

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

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

emacs --daemon

Isso criará um servidor emacs, e você poderá conectá-lo a partir do terminal ou da 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"

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

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

Portanto, se você precisar abrir um arquivo que tenha acesso root; use em trampvez disso. Basta executar o seu cliente emacs com o usuário normal e abrir arquivos como este;

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

Isso tornou minha vida mais fácil. Posso abrir meu IDE python pesado e pesado em milissegundos dessa maneira. Você também pode adicionar o emacs --daemon à inicialização do sistema ou criar um arquivo da área de trabalho para o emacsclient. Isso é contigo.

Mais informações sobre o emacs daemon e o cliente emacs podem ser encontrados no wiki;

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

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

Concordo que você deve aprender sobre a compilação do Mx (vincule esse e o próximo erro do Mx a uma sequência de teclas curta).

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

Olhe para registros. Você não apenas pode se lembrar de locais em buffers, mas também de configurações de janelas inteiras (Cx rw - configuração da janela para registrar).

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

Ele realiza a "próxima operação de controle de versão lógica" no arquivo atual, dependendo do estado do arquivo e do back-end do 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 me acostumar, mas acho muito útil.

A combinação de teclas padrão é Cx vv

Existe um TFS.el para integração do emacs no Microsoft TFS . Funciona com qualquer TFS, incluindo o TFS que executa o Codeplex.com.

Etapas básicas de configuração:

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

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 ligações de teclas 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)

compilação, próximo erro e erro anterior são todos comandos muito importantes para o desenvolvimento de C ++ no Emacs (funciona muito bem na saída grep). Etags, visit-tags-table e find-tag também são importantes. O complete.el é um dos grandes hacks desconhecidos do século XX e pode acelerar seus hackers em C ++ por uma ordem de magnitude. Ah, e não vamos esquecer ediff.

Ainda estou aprendendo a usar o controle de versão sem visitar um shell, mas agora que estou executando o commit com muito mais frequência (com o git) provavelmente terei que fazê-lo.

Você também pode achar a barra de guias útil. Emula o único comportamento que perdi ao passar do Eclipse para o Emacs. Limite a "," e "." para passar para a barra de guias anterior e seguinte, evita que você alterne o buffer pressionando Ctrl-x b 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, o entrega em seus pacotes emacs-goodies.

Eu uso o emacs no Windows. o módulo de compilação é bom, mas eu queria que a compilação fosse mais inteligente sobre a linha de comando de compilação que ela sugere. É possível usar "Variáveis ​​de arquivo" para especificarcompile-command , mas eu queria algo um pouco mais inteligente que isso. Então, eu escrevi uma pequena função para ajudar. Ele adivinha o comando de compilação a ser usado, para avisar o usuário durante a execução compile.

A função palpite procura um arquivo vbproj ou csproj ou sln e, se encontrado, sugere o 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 deseja construir um MSI, portanto, 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 lintar o arquivo .js. Como alternativa, sugere nmake.

O código que eu uso fica assim:

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

Tentei fazer isso como "antes do conselho" para a função de compilação, mas não consegui fazê-la funcionar satisfatoriamente. Então, defini uma nova função e a vinculei à mesma combinação de teclas que tenho usado compile.

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

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

Bibliotecas C e chamadas de sistema geralmente são documentadas nas páginas de manual. Para isso você pode usar M-x man. Algumas coisas podem ser melhor documentadas nas 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 intérprete.

Acho que a maioria das outras línguas oferece documentação em formato html. Para isso, tente um navegador incorporado (eu uso o w3m). Defina sua BROWSERvariável de ambiente como um script de wrapper emacsclient -e "(w3m-goto-url-new-session \"$@\")"(on * nix), para o caso de algo abrir um navegador e você desejar que ele seja aberto no emacs.

Eu sei que este é um post muito antigo. Mas essa pergunta é válida para iniciantes no emacs.

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

Para uma configuração rápida, sugiro que você vá para esta página eglot . A IMO eglot faz seu trabalho muito bem. Ele se integra bem a pacotes de conclusão automática, como empresa. Fornece referência de localização e muito 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 comandos shell. Estou trabalhando neste projeto eproj . Vai demorar um pouco para concluir. Mas tudo o que faz é mapear o comando shell para o tipo de projeto. E cria seu projeto via shell. Faz o mesmo para executar o comando. Talvez eu precise de ajuda para concluir este projeto. Ele não está pronto para uso, mas se você conhece um pouco do elisp, pode seguir o código.

Além disso, é sempre melhor usar o comando emacs compile.

Para controle de versão, ainda não vi nenhum outro pacote que possa corresponder ao poder do 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 classe são fornecidas pelo protocolo do servidor de idiomas.

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

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

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

Verdadeiramente o emacs pode ser feito para fazer qualquer coisa.

Nos últimos anos, Clang se tornou uma parte importante do suporte ao Emacs C ++. Atila Neves falou sobre o CppCon 2015: "Emacs como um IDE C ++"

São 16 minutos de conversa, onde ele mostra soluções para os seguintes tópicos:

• Ir para definição
• Conclusão automática
• Destaque de sintaxe em tempo real
• Localizar arquivo no projeto

Slides podem ser encontrados aqui .

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

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

De longe, este programa poderia usar melhorias. Mas então também poderia usar as pessoas que trabalham nele para melhorá-lo.

Disclaimer: Eu trabalho no realgud

Tente o modo lsp. Agora você pode usar outra funcionalidade IDE dentro do emacs que se conecta ao servidor. Procure mais informações: lsp-mode