Pergunta

Atualmente meu fluxo de trabalho com 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 uso para digitar comandos compile ou make, e a parte superior geralmente é algum tipo de documentação ou arquivo README que desejo consultar enquanto estou trabalhando.Agora eu sei que existem alguns usuários bastante experientes do Emacs por aí, e estou curioso para saber quais 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 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 ajustar essas funções, mas e o resto?Além disso, se for necessário focar em uma linguagem específica, eu diria que deveria ser C++.

Editar: 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 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 C++ STL (se eu esqueci a sintaxe exata de hash_map, por exemplo)?

Foi útil?

Solução

Você terá que ser específico quanto ao que entende por "o resto".Exceto pelo inspetor de objetos (que eu saiba), o emacs faz tudo isso com bastante facilidade:

  • editor (óbvio)
  • compilador - basta executar M-x compile e digite seu comando de compilação.A partir daí, você pode simplesmente M-x compile e use o padrão.O Emacs irá capturar erros do compilador C/C++ (funciona melhor com GCC) e ajudá-lo a navegar para linhas com avisos ou erros.
  • Depuração - da mesma forma, quando quiser depurar, digite M-x gdb e 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 outra documentação:O Emacs também possui um leitor de páginas de manual e, para todo o resto, existe a web e os livros.
  • controle de versão - existem muitas ligações Emacs para vários backends VCS (CVS, SCCS, RCS, SVN, GIT vêm à mente)

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

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

Como mostra o segundo link, é possível procurar funções (e qualquer outra coisa) em outra documentação, mesmo que não haja suporte imediato.

Outras dicas

Eu tenho que recomendar Navegador de código Emacs como um ambiente de estilo IDE mais "tradicional" para emacs.

EDITAR:Eu também recomendo agora Magito altamente superior à interface VCS padrão no emacs.

Em vez de executar um comando make na janela do shell, você tentou compilar o M-x?Ele executará seu comando make, exibirá erros e, em muitos casos, tornará muito fácil pular 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ê é fã de IDEs, também pode dar uma olhada no pacote speedbar do emacs (M-x speedbar).E, se ainda não o fez, aprenda como usar tabelas de tags para navegar em seu código.

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

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

linhas de descarga, campos numéricos de classificação, funções de substituição regexp e retângulo podem ser realmente úteis para extrair 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 como escrever funções auxiliares do Perforce, como culpa (escrever as suas próprias significa que você pode fazer com que ela se comporte 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 em determinado momento, que corresponde aos padrões de codificação com os quais estou trabalhando.

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

Você pode encontrar uma descrição detalhada da integração do emacs e do controle de versão em meu site.Também estou trabalhando em um 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, há várias coisas que você pode usar, dependendo de qual sistema de controle de versão você usa.Mas algumas das funcionalidades são comuns a todos eles.

vc.el é a maneira integrada de lidar com o controle de versão em nível de arquivo.Possui backends para a maioria dos sistemas de controle de versão.Por exemplo, o backend do Subversion vem com o Emacs, e existem backends git e outros disponíveis em outras fontes.

O comando mais útil é C-x v v (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 religa C-x C-q para fazer check-in e check-out de arquivos se você estiver usando um sistema que precisa disso (como RCS).

Outros comandos muito úteis são C-x v l e C-x v = que mostram o log e a comparação atual do arquivo que você está usando.

Mas para obter produtividade real, você deve evitar usar 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 abrangendo vários arquivos.

A maioria deles é fortemente influenciada ou baseada no original pcl-cvs/pcvs para CVS.Existem até dois deles que vêm com subversão, psvn.el e dsvn.el.Existem pacotes para git etc.

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

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

Para solucionar 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

Isso criará um servidor emacs, então você poderá conectá-lo a partir do terminal ou da GUI.Também recomendo criar alguns aliases para facilitar a ligação. 

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 será iniciado ainda mais rápido que o gedit, prometo.

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

Então, se você precisar abrir um arquivo que tenha acesso root;usar tramp em vez de.Basta executar seu cliente emacs com seu 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 personalizado em milissegundos dessa maneira.Você também pode adicionar emacs --daemon à inicialização do sistema ou criar um arquivo de desktop para 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

Concordo que você deve aprender sobre a compilação M-x (vincule isso e o próximo erro M-x a uma curta sequência de teclas).

Aprenda sobre as ligações para controle de versão (por exemplo,vc-diff, vc-próxima ação, etc.)

Olhe nos registros.Você não só pode lembrar locais em buffers, mas também configurações de janelas inteiras (C-x r w - configuração de janela para registro).

Um ponto de partida (que pode não ser óbvio) para explorar os recursos VC do Emacs é M-x vc-próxima ação.

Ele executa a "próxima operação lógica de controle de versão" no arquivo atual, dependendo do estado do arquivo e do back-end do VC.Então se o arquivo não estiver sob controle de versão, ele o registra, se o arquivo foi alterado, as alterações são enviadas etc.

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

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

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

Etapas básicas para configuração:

  1. Coloque tfs.el em 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 em seu arquivo .emacs, defina associações de teclas locais ou globais para 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)

compile, next-error e previous-error são comandos muito importantes para o desenvolvimento de C++ no Emacs (funciona muito bem na saída do grep também).Etags, visit-tags-table e find-tag também são importantes.conclusão.el é um dos grandes hacks desconhecidos do século 20 e pode acelerar seu hacking em C++ em uma ordem de magnitude.Ah, e não vamos esquecer ediff.

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

Você também pode encontrar Barra de abas útil.Ele emula o único comportamento que perdi ao mudar do Eclipse para o Emacs.Vinculado a "," e "". Para se mudar para a barra de guia anterior e a próxima, ele revive você de trocar o buffer pelo 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, entretanto, 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 em relação à linha de comando de compilação que ele sugere. É possível usar "Variáveis ​​de Arquivo" para especificar compile-command, mas eu queria algo um pouco mais inteligente do que isso.Então escrevi uma pequena função para ajudar.Ele adivinha o comando de compilação a ser usado, para avisar o usuário, ao executar compile.

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

O código que uso é 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 vinculei-a à mesma combinação de teclas que venho usando há compile.

EDITAR existe agora "smarter-compile.el", o que leva essa ideia 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 são normalmente documentadas em páginas de manual.Para isso você pode usar M-x man.Algumas coisas podem ser melhor documentadas em páginas de informações;usar 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 linguagens oferece documentação em formato HTML.Para isso, experimente um navegador incorporado (eu uso w3m).Defina seu BROWSER variável de ambiente para um script wrapper em torno emacsclient -e "(w3m-goto-url-new-session \"$@\")" (em *nix), caso algo possa abrir um navegador e você queira que ele seja aberto dentro do emacs.

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

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

Para uma configuração rápida, recomendo que você vá para esta página eglota .O eglot da IMO faz seu trabalho muito bem.Ele se integra bem com pacotes de preenchimento automático, como empresa.Fornece referência de localização e muito mais.

Também para um depurador, você pode precisar de depuradores específicos para linguagens específicas.Você pode usar o gdb no emacs.Basta digitar M-x gdb .

Para compilar seu código, é melhor usar comandos shell.Estou trabalhando neste projeto eproj.Vai demorar um pouco para concluí-lo.Mas tudo o que ele 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.Posso precisar de ajuda para concluir este projeto.Não está pronto para uso, mas se você conhece um pouco de elisp, pode ler o código.

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

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

A pesquisa de objetos e de classes é fornecida pelo protocolo do servidor de linguagem.

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

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

Para preenchimento automático, acho modo empresa muito útil.

Na verdade, o emacs pode ser feito para fazer qualquer coisa.

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

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

  • Ir para a definição
  • Preenchimento automático
  • Destaque de sintaxe instantâneo
  • Localizar arquivo no projeto

Os slides podem ser encontrados aqui.

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 considero útil são os analisadores de mensagens de localização, de modo que, se você tiver um rastreamento de pilha de chamadas e quiser editar em um local específico da pilha de chamadas, essa interface front-end poderá fazer isso.

De longe, este programa poderia ser melhorado.Mas também poderia usar pessoas trabalhando nisso para melhorá-lo.

Isenção de responsabilidade:Eu trabalho no realgud

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top