Vim Cookbook
por Steve Oualline

Se você escreve rapidamente, seus dedos podem facilmente adiantar-se à sua mente. Frequentemente as pessoas transpõe os caracteres. Por exemplo, a palavra “que” é escrita “qeu”.

Para trocar dois caracteres, por exemplo o “e” pelo “u”, coloque o cursor sob o “e” e escreva xp.

O comando “x” apaga um caracter (o “e”), e o “p” cola ele após o cursor (que está agora sob o “u”).

Suponha que você queira trocar todas as ocorrências da palavra “idiota” pela palavra “gerente”. Mas você quer ter a chance de revisar cada alteração antes de fazê-la.

Aqui está o que você deve fazer:

Repita os passos 4 e 5 até que você tenha substituído todas as ocorrências.

Uma igreja recém comprou um computador e estava aprendendo a usar o mesmo. A secretária da igreja decidiu criar uma carta padrão para ser usada em serviços de funeral. Onde deveria ficar o nome da pessoa ela colocou a palavra “<nome>”. Quando ocorria um funeral ela trocava esta palavra pelo nome verdadeiro do falecido.

Certo dia houveram dois funerais, primeiro para uma senhora chamada Maria, e depois para alguém chamada Edna. Então a secretária usou a substituição global para trocar “<nome>” para “Maria”. Até aí, tudo bem. A seguir ela gerou o serviço para o segundo funeral trocando a palavra “Maria” por “Edna”. Este foi um erro...

Imagine a surpresa do Ministro quando ele começou a ler a parte que continha o Credo Apostólico e disse "Nascido da Virgem Edna"...

Suponha que você quer trocar todas as ocorrências da palavra “idiota” pela palavra “gerente”. Mas você quer ter a oportunidade de revisar cada troca antes de fazer a mesma.

Execute o comando:

:%s/\<idiota\>/gerente/gc

Este comando vai fazer a alteração e fazer uma pausa após a alteração para dar a você uma chance de confirmar a mesma. Você pode informar “y” para aceitar a alteração ou “n” para recusar a mesma.

As partes deste comando são:

Suponha que você queira substituir todas as ocorrências da palavra “idiota” pela palavra “gerente”. Nenhuma confirmação é necessária, por que todos os idiotas são gerentes.

Use o comando:

:%s/\<idiota\>/gerente/g

As partes deste comando são:

Suponha que você queira mover um parágrafo do início do documento para o fim do mesmo. Existem várias formas de fazer isto. Neste exemplo, faremos isto usando comandos no estilo Vi. Na próxima seção faremos isto usando comandos Vim visual.

Para fazer a movimentação use os comandos:

Suponha que você queira mover um parágrafo do topo do documento para o fim. Existem várias formas de fazer isto. Neste exemplo, faremos isto usando o modo Visual do Vim. Na seção anterior, fizemos utilizando os comandos no estilo Vi.

Para fazer a movimentação, execute os comandos:

Exise mais de uma forma de copiar texto entre arquivos. Nesta seção usaremos os comandos Vi mais tradicionais. Na próxima seção, faremos a mesma operação usando o modo Visual.

Para copiar um bloco de texto entre arquivos diferentes, execute os seguintes comandos:

Existe mais de uma forma de copiar texto entre arquivos. Nesta seção, usaremos os novos comandos do modo visual. Veja a seção anterior para o velho estilo Vim de fazer as coisas.

Para copiar um bloco de texto entre arquivos, execute os comandos:

Frequentemente você estará editando um arquivo com uma lista de nomes no mesmo. Por exemplo, uma lista de arquivos objeto que fazem parte de um programa.

Por exemplo:

	version.o
	pch.o
	getopt.o
	util.o
	getopt1.o
	inp.o
	patch.o
	backupfile.o

Esta lista ficaria melhor se estivesse em ordem alfabética. Ou pelo menos em ordem ASCII. Para colocar esta lista em ordem alfabética, execute os seguintes comandos:

O resultado fica parecido com o seguinte:

	backupfile.o
	getopt1.o
	getopt.o
	inp.o
	patch.o
	pch.o
	util.o
	version.o

Na prática, o que você costuma ver em arquivos Makefiles (arquivos que são utilizados pelo UNIX para controlar compilações) é mais parecido com o seguinte:

OBJS = \
	version.o	\
	pch.o		\
	getopt.o	\
	util.o		\
	getopt1.o	\
	inp.o		\
	patch.o	\
	backupfile.o

Note que a contra-barra (\) é usada para indicar que a linha continua na linha seguinte. Após fazer o ordenamento, ficamos com algo assim:

OBJS = \
	backupfile.o
	getopt1.o	\
	getopt.o	\
	inp.o		\
	patch.o	\
	pch.o		\
	util.o		\
	version.o	\

Os nomes estão em ordem, mas as contra-barras estão erradas. Não esqueça de corrigir isto usando a edição normal, antes de prosseguir com a compilação.

OBJS = \
	backupfile.o	\
	getopt1.o	\
	getopt.o	\
	inp.o		\
	patch.o	\
	pch.o		\
	util.o		\
	version.o

Frequentemente você estará editando um arquivo com uma lista de nomes no mesmo. Por exemplo, uma lista de arquivos objeto que constituem um programa.

Por exemplo:

	version.o
	pch.o
	getopt.o
	util.o
	getopt1.o
	inp.o
	patch.o
	backupfile.o

Seria legal ter a lista em ordem alfabética. Ou pelo menos em ordem ASCII. Para colocar em ordem alfabética esta lista, execute os seguintes comandos:

Veja a advertência na seção anterior, para uma descrição resumida de problemas que podem ocorrer no uso deste comando.

Um problema com o formato de arquivo usado pelo comando UNIX make é que ele é extremamente minucioso.

Por exemplo, o seguinte comando está correto:

prog: prog.c
	cc -g -o prog prog.c

Mas o seguinte comando não:

prog: prog.c
        cc -g -o prog prog.c

À primeira vista, você pode pensar que os dois são idênticos. Mas veja com mais atenção. A linha com o “cc” no primeiro exemplo inicia com um tab. No segundo exemplo, ela começa com oito espaços. (Você não consegue descobrir a diferença entre um espaço e um tab quando impressos na tela!)

Então como você pode dizer quando está certo ou não, especialmente quando na tela (ou em papel impresso) ambos são idênticos?

A resposta é que você não consegue. Você pode pensar que é um pouco injusto. Especialmente quando o make funciona com a primeira linha e não com a segunda. Mas quem disse que o UNIX era justo?

Por sorte, o Vim tem um modo que te informa exatamente o que há no seu arquivo. Execute o comando:

:set list

Ele coloca o Vim no modo list. Quando o display é colocado no “list mode”, todos os caracteres são impressos. Tabulações são mostradas como “^I” e o fim da linha é apresentado como um $. Desta forma, no list mode, nossos dois exemplos ficam:

prog: prog.c$
^Icc -g -o prog prog.c$

e

prog: prog.c$
      cc -g -o prog prog.c$

Assim é fácil ver qual linha tem a tabulação.

O Vim não é um processador de palavras. Existem algumas coisas que você pode fazer para tornar as coisas mais fáceis quando estiver editando texto.

Processadores de palavras automaticamente passam para a próxima linha quando uma linha que você está escrevendo é maior que as margens. O editor Vim deixa você fazer uma linha tão longa quanto você quiser. Executando o comando:

:set wrapmargin=70

você pode informar ao Vim para quebrar automaticamente linhas maiores que 70 caracteres (você pode ajustar este número para qualquer valor que você quiser).

Isto torna a inserção de texto muito mais fácil. Ele não resolve o problema de edição. Se você entrar um parágrafo e então decidir apagar metade das palavras na primeira linha, o Vim não vai reformatar o texto.

Você pode forçar uma reformatação de um parágrafo executando os comandos:

O programa Vim foi escrito por programadores para programadores. Você pode usar o mesmo para localizar procedimentos dentro de um conjunto de arquivos de programa C ou C++.

Mas antes, você precisa gerar um arquivo de tabela de conteúdo chamado de arquivo “tags”. (Este arquivo recebe o nome óbvio de tags). O comando ctags gera estes arquivos de tabela de conteúdo.

Para gerar uma tabela de conteúdo de todos os arquivos de programa C no seu diretório atual, use o comando abaixo:

$ ctags *.c

Para programas C++, use o comando abaixo:

$ ctags *.cpp

Se você utilizar uma extensão diferente que .cpp para seus arquivos C++, use a mesma em vez de .cpp.

Uma vez este arquivo seja gerado, você pode informar ao Vim que você quer editar uma função, e ele irá encontrar o arquivo que contém aquela função, e posicionar você lá. Por exemplo, se você quer editar a função write_file, use o comando abaixo:

$ vim -t write_file

Agora, suponha que você está examinando a função write_file, e esta chama a função setup_data e você quer dar uma olhada na mesma. Para saltar para aquela função, posicione o cursor no início de setup_data e pressione Ctrl+]. Isto informa ao Vim que ele deve saltar para a definição daquela função. Este reposicionamento irá ocorrer mesmo que o Vim tenha que abrir outro arquivo para isto.

Se você editou o arquivo atual e não gravou as alterações, o Vim vai apresentar uma advertência e irá ignorar o comando Ctrl+].

Eu gosto de colcoar grandes caixas de comentário no início de cada uma de minhas procedures. Por exemplo:

/*******************************************************
 * Program -- Solve it -- Solves the worlds problems.  *
 *     All of them. At once.   This will be a great    *
 *   program when I finish it.                         *
 *******************************************************/

Desenhar caixas como estas é na melhor das hipóteses tedioso. Mas o Vim possui uma funcionalidade legal chamada abreviações que faz as coisas ficarem mais fáceis.

Primeiro, você precisa criar um arquivo de inicialização do Vim chamado ~/.vimrc (uma primeira olhada e o mesmo se parece com um arquivo de inicialização ex. E é. O modo de comando do Vim é na verdade um modo de editor ex).

O arquivo ~/.vimrc deve conter as seguintes linhas:

:ab #b /*******************************************************
:ab #e *******************************************************/

Estes comandos definem um conjunto de abreviações Vim. O que é uma abreviação Vim? É uma palavra que significa outra palavra. Quando o Vim encontra uma abreviação, ele irá expandir a mesma para a palavra completa. Neste caso definimos um abreviação chamada #b que é expandida para a linha inicial da caixa de comentário. A abreviação #e faz o mesmo.

Desta forma, para criar uma caixa de comentário entre #b<enter>. A tela ficará parecida com:

/*******************************************************

Entre os comentários, incluindo os caracteres “*” iniciais e finais. Finalmente, termine o comentário escrevendo #e<enter>. Isto fará com que o fim do comentário seja inserido.

Esta página foi escrita no Vim. Então como conseguimos entrar com o #b e #e? Fácil, escrevemos #bb e então apagamos um caracter (não poderíamos entrar #b por que seria expandido).

Outros comandos úteis que um programador pode querer colocar no seu ~/.exrc incluem:

:set autoindent
:set autowrite
:ab #d #define
:ab #i #include
:ab #b /*******************************************************
:ab #e *******************************************************/
:ab #l /*-----------------------------------------------------*/
:set sw=4

A configuração autoindent faz com que o Vim indente novas linhas com a mesma quantidade de espaços/tabulações que a linha anterior. Esta opção é muito útil para escrever programas. A configuração de autowrite informa o Vim que ele deve gravar um arquivo antigo quando mudar para um outro arquivo.

As abreviações #d, #i e #l definem termos úteis para programadores.

Finalmente, o comando set sw=4 configura o tamanho do shift (o número de caracteres que um texto é movimentado para os lados com os comandos shift - << e >>)

Esta opção é especialmente útil se você usa indentação de 4 espaços nos seus programas C ou C++ (estudos na Rice University demonstraram que este é o melhor tamanho de indentação).

Você pode utilizar o editor Vim para visualizar arquivos texto. Um dos conjuntos mais úteis de arquivos para navegação são as páginas man. Para isto, montamos uma pipeline de três comandos.

O primeiro comando é o man que obtém a página. O seguinte é o ul, que torna os códigos de escape do sublinhado (underline) e negrito (bold) em algo legível, e finalmente, usamos o Vim para navegar pelo arquivo.

Assim, o nosso comando fica:

$ man subject | ul -i | vim -

A página man será gerada e então apresentada na janela do Vim. Você pode usar seus comandos normais de edição para navegar nos arquivos.

Se você tentou editar um arquivo MS-DOS, deve ter notado que cada linha termina com um caracter ^M. Isto é causado pela forma estranha que o MS-DOS trata o fim-de-linha.

Para remover os caracteres ^M de um arquivo MS-DOS, use o comando abaixo:

:1,$s/{Ctrl+V}{Ctrl+M}//{ENTER}

Este comando comessa com um dois-pontos (:) para fazer o Vim entrar em modo ex. Todos comandos ex começam com um intervalo de linhas, que neste caso é da primeira linha (1) até a última linha ($). A barra indica o início do texto que deve ser substituído. O {Ctrl+V} informa ao Vim que deve tratar o próximo caracter como um caracter normal, se ele tiver algum significado especial. O próximo caracter será {Ctrl+M} (que seria tratado como um {Enter} sem o {Ctrl+V}). A próxima barra termina o texto a ser substituído. O que segue é o texto substituto. Neste caso é nada (//).

Algumas pessoas acham que espaços no fim das linhas inúteis, um desperdício, e horríveis. Para remover os espaços em branco no fim de todas as linhas, execute o comando abaixo:

:1,$s/[ <tab>]*$//

Os dois-pontos (:) fazem com que o Vim entre no modo ex. Todos comandos ex iniciam com um intervalo de linhas, que neste caso é o arquivo inteiro (da linha 1 até a última linha: $).

O primeiro conjunto de barras separa o texto a ser substituído. Os colchetes indicam que qualquer caracter dentro deles serve. Desta forma, [ <tab>] combina com espaço ou tabulação. O asterisco (*) significa que o caracter anterior (espaço ou tabulação) pode ser repetido qualquer número de vezes. O cifrão ($) indica um fim de linha.

Desta forma, [ <tab>]*$ diz ao Vim para procurar por qualquer número de espaços ou tabulações que sejam seguidos por um fim de linha.

Estes são substituídos pelo texto que está entre o próximo conjunto de barras. Neste caso, é nada, e os espaços e tabulações são efetivamente removidos.

Digamos que você tenha editado um arquivo e tenha feito muitas alterações. Ele é um arquivo muito importante e para proteger o mesmo de qualquer edição casual, você protegeu o mesmo contra escrita, mesmo de você mesmo.

O Vim permite que você edite um arquivo protegido com pouca ou nenhuma advertência. O único problema é que quando você tenta sair usando “ZZ” você recebe uma mensagem de erro de resposta:

file.txt    File is read only

e o Vim não é fechado.

O que você pode fazer? Você não quer descartar todas as alterações, mas precisa sair do Vim de forma que você possa ligar a permissão para escrita.

O truque é executar o comando :shell. Este comando coloca você fora do Vim iniciando um processador de comandos (shell) sob o Vim.

Você pode então habilitar a escrita no arquivo:

$ chmod u+w file.txt

e sai do shell, retornando ao Vim

$ exit

Finalmente, você pode forçar o Vim a escrever o arquivo utilizando o comando:

:w!

(O Vim continua pensando que o arquivo está protegido contra escrita, de forma que precisamos convencer o mesmo usando a opção “force” - ! - obrigando-o a escrever o arquivo)

É uma boa idéia ficar o menor tempo possível em um processador de comandos iniciado pelo comando :shell. Isto por que é fácil esquecer que você está rodando sob o Vim. É possível iniciar um shell, e iniciar um Vim, e iniciar um shell, e iniciar um Vim, e... Usando este método, você pode facilmente consumir boa parte dos recursros da máquina e gerar muita confusão.

Mantendo suas sessões :shell curtas, você pode evitar muitos problemas.

Você tem uma lista de nomes na forma:

Sobrenome, Nome

Como mudar para:

Nome Sobrenome

Isto pode ser feito com um comando:

:1,$s/\([^,]*\), \(.*$\)/\2 \1/

O dois-pontos (:) informa ao Vim que este é um comando no estilo ex.

O intervalo de linhas para este comando é o arquivo inteiro, como indicado pelo intervalo 1,¤.

O s (substitute - substituir) informa ao Vim que iremos fazer uma substituição de string.

O texto antigo é uma expressão regular complexa. Os delimitadores \( ... \) são usados para informar ao editor que o texto que combinar com a expressão regular deve receber tratamento especial.

O texto no primeiro \( ... \) é atribuído para \1 no texto substituto. O segundo conjunto de texto dentro de \( ... \) é atribuído para \2, e assim por diante.

Neste caso, a primeira expressão regular é qualquer quantia de caracteres que não inclua uma vírgula. O [^,] significa tudo exceto a vírgula, e o * significa zero ou mais caracteres.

A segunda expressão combina com qualquer coisa: .* até o fim da linha: ¤

O resultado desta substituição é que a primeira palavra na linha é atribuída para o \1, e a segunda parte para \2. Estes valores são usados no fim do comando para trocar as palavras.

Este comando envolve o fgrep, bem como o caracter especial do shell “backtick” (crase).

Para editar todos os arquivos de programa C que contenham a palavra indentation_level execute o comando:

$ vim fgrep -l indentation_level *.c

O comando fgrep -l indentation_level *.c procura em todos os arquivos terminados com .c pela palavra indentation_level, e lista os nomes dos arquivos.

Uma vez que este comando está entre crases (`), o resultado do comando (uma lista de arquivo) toma o lugar do comando na linha de comando.

O editor Vim é então executado nestes arquivos. Os comandos :n{Enter} e :rew{Enter} podem ser usados para trocar de arquivo.

Inicie o Vim.

Execute o comando:

:grep >word< >file-list<

Este comando encontra a primeira localização de word nos arquivos informados e posiciona o cursor naquela linha. Você pode utilizar o comando :cn para encontrar a próxima ocorrência.