Vim - anotações

Trocando as funções entre e

2009-06-30T13:06:00.005-03:00

A tecla é muito usada no Vim, mas muitos consideram-na um entrave na
produtividade pela sua posição, longe da home row do teclado.
Uma solução é usar uma outra tecla próxima e de pouco uso no lugar do . A
tecla preferida é o .

No Ubuntu use:
Sistemas - Preferências - Teclado - Disposições - Opções da disposição -
Comportamento da tecla CapsLock.
Escolha:
Trocar Esc e Caps Lock

Listando todas definições de macro C no modo comando

2009-06-10T09:21:00.003-03:00

Para listar todas definições de uma macro use:

:dlist EOF

É semelhante a

[D e ]D

mas permite também selecionar um intervalo de linhas a serem pesquisadas.
O comando:

:dsearch EOF

pesquisa definições também, mas só lista a primeira.

Saltando para definições de macro C em modo comando

2009-06-10T09:08:00.005-03:00

O comando:

:djump /padrão/

salta para a primeira definição de macro que encontrar no arquivo corrente e nos
includes. É semelhante ao comando de modo normal:

[<Ctrl-D>

porém permite selecionar um intervalo para restringir a procura.
O comando:

:dsplit

faz um ':split' seguido de um ':djump'

Listando as ocorrências de um palavra em modo comando

2009-06-10T08:13:00.006-03:00

O comando:

:{intervalo}ilist /padrão/

mostra todas linhas que tem uma ocorrência do padrão.
A busca vai no arquivo corrente e nos includes.

É semelhante a:

[I e ]I

mas permite restringir a um intervalo de linhas
Por exemplo, listar todas linhas que tenham 'EOF':

:ilist EOF

O comando:

:isearch EOF

é semelhante a ':ilist' mas lista somente a primeira ocorrência.

Pesquisando e saltando para uma palavra em modo comando

2009-06-09T22:54:00.004-03:00

O comando:

{intervalo}:ijump {contagem} {/padrão/}

procura a primeira ocorrência da palavra dentro do intervalo.
A procura ocorre no arquivo corrente e nos arquivos apontados pela diretiva
'#include'. A 'contagem' diz para saltar para a uma ocorrência específica.

Exemplo:

:ijump /define\s*EOF/

procura a primeira linha que contenha 'define EOF'. Neste caso, ela está dentro do arquivo de include 'stdio.h'.
Faz o mesmo que

[<Ctrl-I> e ]<Ctrl-I>

porém pode restringir a um intervalo de linhas.
O comando:

:isplit /padrão/

funciona como um ':split' seguido de um ':ijump'.

Opção para tornar default a flag 'g' do substitute

2009-06-08T18:28:00.004-03:00

O comando ':substitute' por default só altera a 1ª ocorrência de uma linha.
Para alterar todas use a flag 'g'.

Para torna-la o default use:

:set gdefault

Agora o ':substitute' altera todas ocorrências sempre.

No entanto, isso poderá quebrar scripts que você possa usar.

Repetindo a última substituição

2009-06-08T17:17:00.007-03:00

O comando:

{intervalo}:& {flags} {contagem}

repete o último comando ':substitute' com o mesmo padrão e o mesmo string de substituição, mas sem as mesmas flags.

Exemplo, o comando seguinte substitui somente a 1ª ocorrência:

1 substitute /a\+/b/p
Test b* aa* a*

Agora para repetir, mas de com flag global:

:&g

O comando ':&' sem argumentos repete o último ':substitute'.

O comando de modo normal '&' repete também o último ':substitute'. Pode usar uma
contagem para repetir '&'.
O comando:

:{intervalo}~ {flags} {contagem}

repete o último 'substitute' com o mesmo string de substituição mas com último string usado em um padrão de pesquisa (comandos '/' ou '?').

Substituindo texto forçando a opção 'magic'

2009-06-08T17:02:00.002-03:00

A opção 'magic' controla se certos caracteres tem valor especial. Para serem
usados literalmente tem que ser escapados.
Exemplo, '*', significa ('magic') nenhum ou 1 ou mais ocorrências.
Se desligar a opção ('nomagic') ela será usada literalmente.

Se quiser fazer um ':substitute' forçando a opção 'magic' ligada use:

:smagic /a*/b/g

Para forçar 'nomagic':

:snomagic /a*/b/g

Imprimindo linhas na tela mostrando os caracteres invisíveis

2009-06-02T15:16:00.001-03:00

Para imprimir linhas na tela mas mostrando os caracteres invisíveis (fim de
linha, tab, etc) use:

:1,5list

Um '$' é colocado após o fim-de-linha e os caracteres invisíveis são mostrados
no formato '^letra'.

Imprimindo linhas na tela

2009-06-02T15:12:00.001-03:00

Se quiser imprimir linhas na tela use:

:1,5print

Se a opção 'number' não estiver ligada, use:

:1,5#

para imprimir linhas pré-fixadas com o número.

Inserindo texto pela linha de comando

2009-06-02T14:57:00.002-03:00

Suponha que você que inserir texto pela linha de comando.
Use:

:1 append

para inserir texto após a linha 1.
Use:

:1 insert

para inserir texto antes da linha 1.
Digite o texto.
Para encerrar faça uma linha com somente um ponto (.).

Opção para desligar o mapeamento recursivo

2009-05-31T13:13:00.002-03:00

Por default, o Vim faz mapeamentos recursivos.
Para desligar isso use a opção:

:set noremap

Mas isto pode quebrar alguns scripts.
Use, ao invés, o comando:

:noremap ...

Forçando a expansão e a não-expansão de uma abreviação

2009-05-31T09:41:00.001-03:00

O comando:

<Ctrl-]>

força a expansão da abreviação no modo inserção.
O comando:

<Ctrl-C>

faz com se sai do modo inserçao. A diferença com <Esc> é que ele não expande a
abreviação antes de entrar no modo normal.

Opção para definir o tamanho máximo de uma tag

2009-05-29T11:34:00.001-03:00

Alguns sistemas limitam o tamanho máximo de um nome de função. Se você quiser
limitar isto quando pesquisando tags use:

:set taglength=número

Testando se o Vim pode localizar o arquivo de uma diretiva #include

2009-05-27T17:55:00.003-03:00

Para listar todos arquivos '#include' não puderam ser localizados, use:

:checkpath

Ele verifica não somente as diretivas '#include' do arquivo sendo editado como
quaisquer arquivos que as diretivas incluem e assim por diante.
Para os includes que falharam inclua os paths necessários na opção 'path'.
Para listar todos arquivos '#include' use:

:checkpath!

Opção para definir que caracteres são usados como par de delimitadores

2009-05-27T12:47:00.003-03:00

Para definir que caracteres serão identificados pelo comando '%' use a opção:

:set matchpairs = (:),{:},[:]

Para identificar o par '<>' (tag HTML) use:

:set matchpairs+=<:>

Comparando visualmente dois arquivos

2009-05-25T13:38:00.003-03:00

Suponha que você quer comparar dois arquivos que diferem em poucas edições.
Abra duas janelas com os dois arquivos.
Agora execute o comando em cada janela:

:set scrollbind

Agora quando uma janela rola a outra rola também.
Se quiser parar a sincronização em um janela:

:set noscrollbind

E localizado o ponto desejado no arquivo, recomeça a rolar ao mesmo tempo a
partir desses locais:

:set scrollbind

Para voltar a sincronizar as janelas (isto é, linha 1 com linha 1), ligue
'scrollbind' em ambas janelas e use:

:syncbind

A opção:

set scrollopt=

controla como o scrollbind trabalha.

Opção para definir que palavra causa indentação na próxima instrução C

2009-05-25T13:34:00.003-03:00

Para que uma palavra dispare uma indentação na próxima instrução C use a opção:

:set cinwords=string

O valor default é:

:set cinwords=if,else,while,do,for,switch

Opção para definir quanto espaço uma indentação C terá

2009-05-25T12:43:00.002-03:00

Para controlar quanto irá ter um indentação C use a opção:

:set cinoptions=string

Aonde o 'string' consiste de uma lista pares chave-indentação separados por
vírgulas.
A 'chave' é uma única letra que diz que parte do programa será afetada.
A 'indentação' diz quantos espaços será usado na indentação. Pode ser um número
negativo. Também pode ser em múltiplos de 'shiftwidth'.

Opção para definir que tecla dispara uma indentação C

2009-05-25T08:48:00.003-03:00

Uma lista de teclas que quando usadas no modo inserção causam re-indentação da
linha corrente. Somente usada se 'cident' ou 'indentexpr'.
Use:

:set cinkeys=string

O string é uma lista de pares 'caractere de tipo caractere da tecla'.
Os tipos podem ser:
! a tecla seguinte não é inserida. Isto é útil se você quiser definir uma tecla
  que só dispara a re-indentação da linha. <Ctrl-F> é a tecla default nesse
  caso.
* a linha será re-indentada antes que a tecla seja inserida.
0 a tecla causa indentação somente se ela é o primeiro caractere digitado na
  linha.
As teclas-caractere podem ser:

<nome>    O nome da tecla.
^nome     O nome de uma tecla de controle.
o         Diz ao Vim para indentar quando for usado o comando 'o'.
O         Diz ao Vim para indentar quando for usado o comando 'O'.
e         Re-indenta a linha quando for digitado o último 'e' de else.
:         Re-indenta quando for digitado um ':' após um label ou 'case'.

O valor default é:

0{,0},0),:,0#,!^F,o,O,e

que especifica que uma indentação ocorre se:

0{  se foi digitado '{' como primeiro caractere em uma linha.
0}  se foi digitado '}' como primeiro caractere em uma linha.
0)  se foi digitado ')' como primeiro caractere em uma linha.
:   se foi digitado ')' depois de um label ou instrução 'case'.
0#  se foi digitado '#' como primeiro caractere em uma linha.
!^F se foi digitado <Ctrl-F> (o qual não é inserido).
o   se foi digitado um <CR> em qualquer lugar ou usou o comando 'o' (não no modo
    inserção).
O   se foi usado o comando 'O' (não no modo inserção).
e   se foi digitado o segundo 'e' para um 'else' no início de uma linha.

Opção para definir um programa externo de formatação

2009-05-24T09:15:00.001-03:00

Você pode definir que programa de formatação que o Vim usa quando o comando '='
é usado.
Se não for definido o Vim usa a rotina interna de indentação que indenta
programas C ou C++.
Por exemplo, para usar o programa GNU de indentação 'indent':

:set equalprg=/usr/local/bin/indent

Opção para indentar em múltiplos de shiftwidth

2009-05-24T08:49:00.004-03:00

Por default, um comando de indentação (>, <) insere 'shiftwidth' espaços mesmo
que a linha já tenha espaços na frente da linha. Isso pode distorcer o layout
desejado.

Para evitar isso ligue a opção:

:set shiftround

para que o Vim sempre insira espaços em múltiplos de 'shiftwidth'.

Os comandos de modo inserção:

<Ctrl-T>
<Ctrl-D>

sempre arredondam as indentações para múltiplos de 'shiftwidth'.

Usando um modeline para configurar as opções de tabs

2009-05-24T08:04:00.002-03:00

O Vim dá várias opções para tratar o uso de tabs dentro dos arquivos.
No entanto, isso significa que cada pessoa pode tratar o mesmo arquivo de
maneira diferente.

Uma solução é colocar um comentário especial no início ou fim do arquivo
informando que tab stops usar.

Por exemplo:

/* vim:tabstop=8:expandtabs:shiftwidth=8 */

O Vim ao ler esse comentário irá configurar as opções para você.

Colando texto do registrador com indentação no modo normal

2009-05-23T14:20:00.005-03:00

Se você tem algum texto em um registrador, você usaria no modo normal:

"registradorp
"registradorP

para colar. Mas se o registrador já estiver indentado e a auto-indentação estiver ligada o resultado poderá ser confuso (dupla-indentação).
O comando:

"registrador]p
"registrador]P

faz a mesma coisa, mas também ajusta a indentação conforme o local.

Colando texto do registrador com indentação no modo inserção

2009-05-23T11:27:00.006-03:00

Normalmente, no modo inserção, para inserir o conteúdo de registradores se usa:

<Ctrl-R>registrador

Mas isso, especialmente em código de programas, pode causar problemas.

Se o conteúdo do registrador é uma cópia de um código já indentado, ao inserir, o
Vim usa essa indentação e mais a indentação automática, causando uma dupla
indentação. Isso produz um layout errado.

Uma alternativa é usar:

<Ctrl-R><Ctrl-O>registrador

isso insere o conteúdo do registrador mas sem fazer a auto-indentação. O problema é que o conteúdo já tem a indentação original e pode não ser coerente com o local
aonde está sendo inserindo.

Para inserir com o Vim recalculando a indentação correta use:

<Ctrl-R><Ctrl-P>registrador

Removendo a indentação automática temporariamente

2009-05-23T10:47:00.004-03:00

Suponha que você está editando um programa com 'autoindent' gerando indentações automáticas.
Num certo ponto você deseja colocar um bloco de comentários sem ser afetado pela
indentação automática.

Um modo é usar

<Ctrl-D>

repetidamente.
Outra é digitar:

 0<Ctrl-D>

Isso faz com que o editor remova toda indentação automática e coloque o cursor
na coluna 1, enquanto estiver no modo inserção.

Agora, você quer digitar um label ou uma diretiva '#ifdef' na coluna 1, mas
somente em uma linha e depois volta para a autoindentação.
Use:

 ^<Ctrl-D>

quando você entrar na linha seguinte volta a autoindentação.

Evitando a repetição de uma seleção no modo seleção

2009-05-23T10:26:00.004-03:00

Após a execução de um mapeamento e menu a seleção do modo seleção é restaurada (a não ser que a área tenha sido deletada).

Para evitar, especialmente em macros que selecionam, fazem algum coisa e depois
se quer que a seleção desapareça, use o comando:

gV

Mudando do modo seleção para o modo visual

2009-05-23T09:44:00.002-03:00

Se você estiver no modo seleção, use o comando:

<Ctrl-O>

para executar um único comando no modo visual. Após isso, volta ao modo seleção.
Para mudar para o modo visual sem retornar para o modo seleção use:

<Ctrl-G>

Alterando e deletando texto com o modo seleção

2009-05-23T09:09:00.005-03:00

O modo seleção é semelhante ao modo visual, porém mais limitado.
No modo seleção você só pode usar <Backspace> para deletar e caracteres visíveis
para substituir.
Isso é mais rápido que a seleção visual porque você não precisar entrar um
comando no final para fazer a mudança. Mas o repertório é bem menor.

Para selecionar use:

gh    inicie uma seleção caractere por caractere.
gH    inicie uma seleção linha a linha.
gCtrl-H inicie uma seleção de bloco.

Mova o cursor com teclas de direção (flechas) para completar a seleção.

Para deletar use:

<BS> ou <Ctrl-H>

Para substituir:

Digite o primeiro caractere visível, o editor entra em modo
inserção.
Continue a entrar o texto.
<Esc>

Codificando um bloco de texto

2009-05-22T21:29:00.002-03:00

Com um texto selecionado, use o comando:

g?

para codificar (tornar incompreensível) ou para retirar a codificação.
É usado o esquema de codificação Rot13.
Para descodificar, chame de novo o comando.

Abrindo uma janela com o primeiro arquivo que contenha uma palavra

2009-05-22T07:26:00.003-03:00

Se você posicionar o cursor sob uma palavra e pressionar:

<Ctrl-W><Ctrl-I>

o vim pesquisará no arquivo corrente e nos includes, retornando a primeira
ocorrência na nova janela.

Abrindo uma janela com o arquivo alternado

2009-05-22T07:23:00.001-03:00

Para dividir a janela e editar o arquivo alternado use:

<Ctrl-W><Ctrl-^>

Movendo o cursor no modo inserção

2009-05-20T18:44:00.006-03:00

No modo inserção não se pode usar as teclas tradicionais de movimento (hjkl).
Use ao invés:

<Left>
<Right>
<Up>
<Down>

Pressionando ao mesmo tempo a tecla

<Ctrl>

o movimento é por palavra.

<Home>

move para o início e <End> para o fim da linha.
Para mover para o início:

<C-Home>

para o fim da linha:

 <C-End>

Para mover uma tela para frente e para trás:

<PageUp> e <PageDown>

Abrindo um arquivo com a execução de um comando

2009-05-19T22:39:00.004-03:00

Você pode iniciar o Vim executando um comando logo no início.
Para posicionar o cursor numa linha use:

gvim +87 file.c

Para pesquisar um string e posicionar o cursor :

gvim +/include file.c

Para executar um comando logo após abrir um arquivo:

gvim +/set\ dir=/tmp file.c

Se houver espaços na expressão regular e no comando eles deve ser escapados (\).

Usando o registrador-expressão (=) para entrar resultados de uma expressão no texto

2009-05-16T14:25:00.010-03:00

O registrador-expressão permite que você avalie uma expressão e coloque o
resultado em alguma parte do texto.

Em modo normal, use a sequencia:

"=

o Vim salta para a linha de comando, aonde você pode digitar uma expressão, por exemplo:

38*56

em seguida, mova o cursor e cole resultado:

Em modo inserção pode-se usar a sequencia:

<Ctrl-R>"= (o Vim salta para linha de comando)
38*56
<Enter>

A expressão pode conter os operadores aritméticos comuns (*,+,-,/, etc) assim como as várias funções e operadores especializados do Vim.

Pode usar variáveis ambientais usando $NOME (por exemplo, $HOME), assim como variáveis Vim, simplesmente usando o nome dela como 'LineSize', por exemplo.

A linha de comando também dispõe de um histórico de expressões que pode ser recuperadas com as teclas de direção.

Usando o registrador buraco negro para evitar de salvar o texto deletado

2009-05-16T13:55:00.006-03:00

Ao colocar texto no registrador 'buraco negro' (_), faz com que ele desapareça.

O registrador 'buraco negro' é útil se você quiser deletar um texto (com d ou c, por exemplo), mas não quer que ele vá para os registradores 1 a 9, como de costume.

Por exemplo, para deletar uma linha e coloca-la no registrador 1 use:

dd

Mas para deletar e não mexer no registrador 1 use

"_dd

Usando registradores especiais

2009-05-16T13:32:00.003-03:00

O Vim possui uma série de registradores especiais. Aqui tem o seu conteúdo e se pode ser gravado pelo usuário:

0     O último texto copiado                      gravável
-     O último texto deletado menor que uma linha read-only
.     O último texto inserido                     read-only
%     O nome do arquivo corrente                  read-only
#     O nome do arquivo alternado                 read-only
/     O último string pesquisado                  read-only
:     O último comando ':'                        read-only
_     O registrador 'buraco negro'                gravável
=     Uma expressão                               read-only
*     O texto selecionado com o mouse             gravável

Mostrando o conteúdo dos registradores

2009-05-15T19:38:00.002-03:00

Use o comando:

:registers

Para mostrar registradores específicos:

:registers ax

mostra o conteúdo dos registradores 'a' e 'x'.

Colando texto

2009-05-15T09:38:00.003-03:00

Após comandos de deleção ou cópia, você pode colar o texto em outro lugar.
Cola após o cursor:

{"registrador}p

Cola antes do cursor:

{"registrador}P

Cola após o cursor e deixa o cursor depois do novo texto:

{"registrador}gp

Cola antes do cursor e deixa o cursor depois do novo texto:

{"registrador}gP

Opção para definir que caracteres tem significado especial na expressão regular

2009-05-14T21:42:00.003-03:00

A opção 'magic' quando ligada define que caracteres tem valor especial em uma
expressão regular.
Por exemplo '*' significa zero ou mais ocorrências.
Recomenda-se sempre deixa-la ligada (o default) para portabilidade.

Expressão regular: agrupamento

2009-05-14T21:05:00.004-03:00

Você pode especificar um grupo na expressão regular através de:

\(...\)

Por exemplo:

a\(XY\)*b

obtém 'ab', 'aXYb', 'aXYXYb', etc.
Quando você define o grupo, o primeiro é assinalado ao item \1.
Por exemplo, para achar palavras repetidas:

\(\<\a\+\>\) \1

Descrevendo a expressão:

Inicia um grupo \(
  início de palavra \<
  uma ou mais letras, o máximo possível \a\+
  fim de palavra \)
Fim do grupo \)
Um espaço
A ocorrência obtida dentro do grupo anterior

O primeiro grupo é assinalado a \1, o segundo a \2, e assim por diante.

Expressão regular: Classe de caracteres pré-definida

2009-05-14T17:25:00.003-03:00

O Vim tem algumas classes de caracteres pré-definidas para coleções comuns de
caracteres.
Por exemplo, todas as letras maiúsculas, você pode usar a expressão [A-Z] ou
a classe:

[:upper]

obtém um caractere de letras maiúsculas.
Para obter um caractere dentro alfabeto inteiro use:

[[:upper][:lower]]

Opção para definir o número mudanças salvas pelo Vim para fazer undo

2009-05-13T09:06:00.003-03:00

Use a opção:

:set undolevels=5000

para limitar a 5000 mudanças que salvas para poderem ser desfeitas pelo Vim.

Opção para usar '~' com comando de movimento

2009-05-12T19:31:00.002-03:00

Quando a opção essa opção está ligada:

:set tildeop

o comando '~' troca o case do caractere.
Quando desligada:

:set notildeop

a sintaxe do comando muda para '~movimento'.
Por exemplo:

~fq

muda o case de todos caracteres até e inclusive o primeiro 'q'.

Opção para habilitar a entrada de dígrafos usando Backspace

2009-05-12T19:15:00.002-03:00

Se você pretende entrar muitos dígrafos ligue a opção:

:set digraph

Agora você pode entrar dígrafos com a sequencia:

caractere <BS> caractere

Por exemplo:

c<BS>o

é o caractere ©.
Naturalmente, essa convenção dificulta a correção usando backspace, pois agora
ele cria um dígrafo, não deleta o caractere.
Para desligar a opção:

:set nodigraph

Posicionando a linha do cursor no meio da tela

2009-05-10T22:19:00.001-03:00

Para posicionar a linha do cursor no meio da tela use:

zz

que deixa o cursor na sua coluna atual ou

z.

que deixa o cursor na primeiro caractere não-branco.

Posicionando a linha do cursor no rodapé da janela

2009-05-10T19:42:00.004-03:00

Use:

z-
88z-

para posicionar na linha final da tela, com o cursor no primeiro caractere
não-branco.

zb
15zb

para posicionar na linha final da tela, com o cursor na coluna original.
A linha final é alterada pelo valor da opção 'scrolloff'.

Posicionando a linha do cursor no topo da janela

2009-05-10T15:52:00.005-03:00

Se você quiser posicionar a linha do cursor no topo da janela use:

z<Enter>

(no entanto, a opção 'scrolloff' pode deixar uma margem de linhas acima dela).
Para posicionar uma linha qualquer:

88z<Enter>

Posiciona a linha 88 no topo.
O comando 'z' além de mover para o topo, deixa o cursor no 1º caractere
não-branco da linha.
Se quiser que o cursor continue na coluna original use:

zt
88zt

Opção para definir quantas linhas avançar/retroceder quando o cursor atinge início/fim da tela

2009-05-10T14:45:00.002-03:00

Quando o cursor atinge o início ou fim da tela, com comandos com o 'j' ou 'k',
essa opção define quantas linhas o Vim avança ou retorna (se houver):

:set scrolljump=5

O default é 1.
Não é usado para comandos de rolagem de tela (<Ctrl-E>, <Ctrl-D>, etc).
Útil para terminais lentos.

Opção para definir quais teclas podem passar o início ou fim de linha

2009-05-07T22:01:00.001-03:00

Use:

:set whichwrap={string}

Define que teclas move o cursor para esquerda/direita em direção à linha
anterior/seguinte.

Repetindo o comandos de salto para caractere

2009-05-07T20:49:00.004-03:00

Para repetir esses comandos (f,F,t,T), use:

Para repetir na direção oposta use:

Pode-se usar contagem de comando:

3;
3,

Opção para definir que caracteres podem ser exibidos literalmente na tela

2009-05-07T20:13:00.003-03:00

Use:

:set isprint={especificação}

Cuidado com a especificação, pois pode bagunçar a tela.

Usa a mesma {especificação} de 'iskeyword'.

Expressão regular: Definindo o fim da ocorrência (match)

2009-05-05T23:51:00.006-03:00

O item '\ze' em uma expressão regular define o local aonde termina uma ocorrência. O texto seguinte é só testado para validar o regex mas não é retornado.

Esse comando é útil quando você quer um texto que deve ser seguido por outro, mas não deseja que ele faça parte da ocorrência.

Exemplo:

end\ze\(if\|for\)

'end', define o fim da ocorrência, seguido de 'if' ou 'for'. Retorna 'end' quando ocorrer 'endif' e 'endfor'.

Pode ser usado múltiplas vezes, o último '\ze' é o que é usado.

Expressão regular: Definindo o início da ocorrência (match)

2009-05-05T20:43:00.013-03:00

O item '\zs' em uma expressão regular define o local aonde começa uma ocorrência. O texto anterior é só testado para validar o regex mas não é retornado.

Esse comando é útil quando você quer um texto que deve ser precedido por outro, mas não deseja que ele faça parte da ocorrência.

Exemplo:

/^\s*\zsif

localiza o início da linha, seguido de zero ou mais espaços, define o início da
ocorrência, seguido de 'if'. A expressão localiza 'if's no início da linha
ignorando os espaços precedentes.
Pode ser usado múltiplas vezes, o último '\zs' é o que é usado:

/\(.\{-}\zsFab\)\{3}

Localiza a terceira ocorrência de 'Fab'.

Saltando para um byte específico do buffer

2009-04-26T10:58:00.001-03:00

Use o comando:

{contagem}go

para saltar para um byte específico do arquivo.
O comando:

:goto {número}

faz o mesmo.
Use o comando

g<Ctrl-G>

para ajudar a ver a posição do cursor.

Arquivo read-only e o gerenciador de versão de fontes

2009-04-26T10:02:00.003-03:00

A opção 'readonly' é ligada automaticamente quando é lido é read-only.

Em uma ocasião você deveria desliga-la: quando você está usando um sistema de
controle de fontes que deixa os arquivo em modo read-only.
Quando você edita-lo no Vim, ele avisa que o arquivo é só para leitura e liga a
opção 'readonly'.

Neste ponto você lembra que esqueceu de dizer ao gerenciador de fontes que você
quer editar o arquivo.

Assim você usa o comando ':shell' para ir ao command prompt e executa comandos
que diz ao gerenciador que você quer editar o arquivo.
Depois de obter a permissão do gerenciador, você volta ao Vim ao entrar 'exit' e
executa o seguinte comando para dizer que o arquivo é editável:

:set noreadonly

Opção que informa se o buffer corrente foi alterado

2009-04-26T09:54:00.002-03:00

A opção 'modified' é ligada automaticamente pelo Vim quando o buffer é
modificado.
Não é necessário ligar essa opção, pois ela é gerencia pelo editor.
No entanto você pode testa-la em vim scripts.

Salvando a edição do arquivo para o swap file

2009-04-26T09:39:00.002-03:00

Se você fez bastante alterações em um arquivo e deseja preserva-las em caso de
crash você usa:

:w

No entanto isso sobrepõe o arquivo original com as alterações.
Uma alterativa é usar o comando:

:preserve

Ele irá gravar todas alterações no swap file somente. O arquivo original
permanece intacto e só será mudado quando você fizer um ':w' ou um 'ZZ'.
Se o sistema cai você pode recuperar os dados mesmo que o arquivo original tenha
sido perdido.
Sem esse comando você precisaria tanto do swap file como do arquivo original
para recuperar os dados.

Opção para forçar o Unix/Linux gravar o swap file

2009-04-25T23:54:00.002-03:00

No Unix/Linux quando você grava um arquivo, os dados normalmente vão para um
buffer de memória e são gravados de fato quando o sistema achar que é o momento.
Isto pode levar alguns segundos.
Se você quiser ter certeza que os dados vão para o disco use:

:set swapsync

Este comando executa uma operação 'sync' depois de cada gravação do swap file
para forçar a gravação em disco.

Desativando o swap file

2009-04-25T23:49:00.002-03:00

Você pode querer desativar o uso de um swap file quando editando um arquivo
muito grande e não se importa com recuperação.
Use:

:set noswapfile

Essa opção é específica para cada buffer.

Escolhendo entre várias versões do swap file

2009-04-25T23:38:00.004-03:00

O Vim busca sempre evitar de gravar sobre um swap file existente. A primeira vez
que edita o swap file chama '.arquivo.txt.swp', na vez seguinte
'.arquivo.txt.swo' e assim por diante.
Você pode dizer ao Vim qual swap file utilizar:

vim -r .arquivo.txt.swo

Para ver qual o nome do swap file que está sendo usado use:

:swapname

A sequência de eventos quando gravando um arquivo

2009-04-25T22:52:00.004-03:00

Sequência de passos quando o Vim grava um arquivo.

1. O Vim verifica se o arquivo foi alterado externamente. Caso tenha
acontecido o editor envia uma aviso e pergunta se quer continuar.
2. Se 'writebackup' ou 'backup' estão ligados, qualquer backup antigo é
removido. O arquivo corrente então é copiado para o backup.
3. O buffer é gravado no arquivo.
4. Se o 'patchmode' está ligado e não existe nenhum arquivo de patch, o arquivo
de backup é renomeado e se torna o arquivo de patch.
5. Se a opção 'backup' não está ligada, e 'writebackup' está ligada, remove o
arquivo de backup.

Entrando no modo restrito pela linha de comando

2009-04-25T18:06:00.001-03:00

Use:

vim -Z

No modo restrito, todos comandos que fazem uso do shell externo são proibidos.
Isso inclui ':shell', , filtragem, etc.

Mostrando a versão e opções de compilação pela linha de comando

2009-04-25T17:57:00.002-03:00

Use a opção:

vim --version

Mostrará a versão do Vim e as opções que foram usadas na compilação do programa.

Mostrando o help da linha de comando

2009-04-25T17:54:00.002-03:00

Use:

vim --help

Será mostrado todos argumentos de linha de comando.

Saindo do modo inserção automaticamente depois de um intervalo de tempo

2009-04-25T11:38:00.005-03:00

Se você entra em modo inserção deve ser pressionado o para voltar para o modo normal para executar alguns comandos.

Elimine essa ação repetitiva definindo o código abaixo em seu .vimrc:

" automaticamente deixe o modo inserção depois de 'updatetime' milisegundos 
" de inatividade.
au CursorHoldI * stopinsert

" defina o 'updatetime' de até 2 segundos quando no modo inserção
au InsertEnter * let updaterestore=&updatetime | set updatetime=2000
au InsertLeave * let &updatetime=updaterestore

O primeiro autocomando tem o evento 'CursorHoldI' que ocorre quando o usuário
não digita nada durante o tempo especificado na opção 'updatetime' e está no
modo inserção. O comando executado será 'stopinsert', o qual equivale a
pressionar no modo inserção.

O autocomando seguinte, ativado no 'InsertEnter' que ocorre antes de entrar no
modo inserção, salva o a opção 'updatetime' e define num valor conveniente, aqui
2 segundos.

O autocomando final, ativado no 'InsertLeave' que ocorre ao deixar o modo
inserção, retorna o valor original da opção 'updatetime'.

Isso permite usar um valor específico de 'updatetime' para sair do modo inserção
sem afetar outras funções, por exemplo mapeamento com várias teclas.

Opção para definir como a última linha do arquivo termina

2009-04-24T20:08:00.003-03:00

O Vim supõe que a última linha termina com um carácter .
Algumas vezes você encontra um arquivo estranho que contém uma linha incompleta.
Quando o Vim encontra este tipo de arquivo, ele liga a opção 'noendofline'.
Se o seu arquivo termina com uma linha completa, a opção 'endofline' é ligada.

Se quiser mudar se o arquivo termina com use:

:set endofline

caso contrário:

:set noendofline

Esta opção só funciona com

:set binary

Definindo uma lista de arquivos com palavras para autocompletar

2009-04-24T11:23:00.003-03:00

Use a seguinte opção:

:set dictionary=arquivo,arquivo,...

Isso define arquivos que serão procurados quando pressionando <Ctrl-N> e
<Ctrl-P> para completar palavras.
Exemplo:

:set dictionary=/home/joao/palavras

Você pode também especificar um dicionário na opção 'complete' com a flag 'k':

:set complete+=/home/joao/palavras

Gravando um arquivo

2009-04-23T18:43:00.008-03:00

Para gravar o buffer (arquivo) use:

:write teste.txt 
:w teste.txt

O comando ':write' não regrava um arquivo existente com o mesmo nome. Use:

:w! teste.txt

para forçar isso.
Para gravar e sair do Vim use:

:wq

para gravar e sair, sem gravar os buffers ocultos use:
read-only se:

:wq!

Para gravar com um novo nome:

:wq b.txt

Para forçar a gravação, caso o nome já exista use:

:wq! b.txt

Para gravar, somente se o buffer foi mudado , e sair use:

:xit

Salvando configurações definidas na linha de comando em um arquivo

2009-04-23T10:58:00.000-03:00

Depois de experimentar com os comandos ':map', ':abbreviate' e ':set', seria legal se
pudesse salva-los e usa-los de novo.
O comando ':mkvimrc' grava todas suas definições em um arquivo:

:mkvimrc {arquivo}

Você pode ler esse arquivo usando o comando:

:source {arquivo}

Somente mapeamentos globais são gravado.

Opção para definir o arquivo com a lista de erros de compilação

2009-04-22T09:44:00.001-03:00

A opção:

:set errorfile=

define o arquivo default que o comando ':clist' e opção de linha de comando '-q'
usarão para percorrer os erros de compilação.
Este arquivo não é usado como saída do comando ':make'.

Usando um arquivo de erros gerado externamente

2009-04-22T09:33:00.003-03:00

Caso você tenha rodado 'make' externo e gerado seu próprio arquivo de erro, você pode dizer ao Vim sobre ele com:

:cfile 'arquivo-de-erro'

'arquivo-de-erro' é a saída do comando 'make' ou do compilador.
Se 'arquivo-de-erro' não foi especificado a opção 'errofile' é usada.

Classificando um bloco de linhas no modo visual

2009-04-21T23:50:00.003-03:00

Ponha o cursor na 1ª linha do bloco.
Inicie o modo visual-linha:

Mova para o final do bloco
Execute o comando de filtro:

!sort

O Vim preenche a linha de comando com:

'<,'>!sort

Classificando linhas usando marca

2009-04-21T14:41:00.003-03:00

Classificando uma série de linhas (de um Makefile):

SOURCES = \
            time.cpp     \
            set_ix.cpp   \
            rio_io.cpp   \
            arm.cpp      \
            app.cpp      \
            amem.cpp     \
            als.cpp      \
            aformat.cpp  \
            adump.cpp    \
            rio.cpp      \
            progress.cpp \
            add.cpp      \
            acp.cpp      \
            rio_glob.cpp

Posicione o cursor no início da lista (a 2ª linha).
Crie uma marca ali:

ma

Posicione o cursor no final da lista.
Entre o filtro:

!'a

O vim traduz na linha de comando para:

:.,$!

Entre o filtro:

sort

As linhas são classificadas.

Percorrendo uma lista de tags selecionadas

2009-04-21T14:09:00.002-03:00

Caso os comandos ':tag {palavra}' ou ':tselect {palavra}' retornem mais uma
ocorrência, use os comandos abaixo:

:tnext

próxima tag

:tprevious

tag anterior

:tNext

tag anterior

:tfirst

primeira tag

:tlast

última tag
Todos suportam o argumento 'contagem' para saltar 'n' ocorrências.

Procurando tag usando expressão regular

2009-04-21T11:20:00.006-03:00

Se você só conhece parte do nome de uma procedure você pode usar o comando

:tag

para procura-la usando uma regexp.
Procure uma procedure que tem 'write' no nome:

:tag /write

Procure uma procedure que comece com 'read':

:tag /^read

Procure uma procedure cuja grafia você tem dúvidas:

:tag /DoFile\|do_file\|Do_File
:tag /[Dd]o_\=[Ff]ile

Esses comandos podem retornar múltiplos resultados.

Mapeamento para percorrer os buffers

2009-04-21T00:42:00.003-03:00

Use:

map <C-right> <ESC>:bn<CR>
map <C-left> <ESC>:bp<CR>

Mapeamentos para retornar o buffer anterior e seguinte respectivamente.

Opção para definir que programa chamar para o comando 'K'

2009-04-21T00:15:00.003-03:00

O comando 'K' chamará um programa externo que receberá a palavra sob o cursor.
O programa a ser chamado está declarado na opção:

:set keywordprg=man

No Unix, o default é 'man'. Pode-se definir ':help' para chamar o help do Vim
passando a palavra.

Indentando um bloco no modo visual

2009-04-21T00:09:00.002-03:00

1. Posicione o cursor no delimitador.
2. Inicie o modo visual:

3. Selecione o bloco {} internamente com:

i}

4. Indente o texto com:

Indentando um bloco de texto entre delimitadores

2009-04-20T22:39:00.006-03:00

Se quiser indentar um nível um texto entre '{}' faça:
Posicione o cursor no delimitador e use o comando-movimento seguinte:

>%

Infelizmente isso indenta o delimitador também. Se você quiser só deslocar o conteúdo do bloco :
Posicione o cursor no delimitador e use comando-objeto_texto:

>i{

'i{' é o objeto texto 'bloco {} interno'.

Mostrando as definições de macro de um programa C

2009-04-20T21:48:00.001-03:00

Mostrando as definições de macro de um programa C.
Mostra a partir do início:

[d

Mostra depois do cursor:

]d

Mostrando uma lista com todas definições de macro de um program C.
Mostra a partir do início:

[D

Mostra depois do cursor:

]D

Saltando para definição da macro C cujo nome está sob o cursor

2009-04-20T21:31:00.005-03:00

Salta para uma definição da macro cujo nome está sob o cursor use.
A pesquisa começa no início do arquivo:

[<Ctrl-D>

A pesquisa começa a partir do cursor:

]<Ctrl-D>

Esses comandos procuram também nos arquivos que estão em '#include'.

Saltando para a linha que tem a palavra sob o cursor

2009-04-20T20:48:00.005-03:00

Para saltar para a primeira ocorrência da palavra sob o cursor:

[<Ctrl-I>

Começa a partir do início do arquivo. Linhas que parecem comentários são
ignoradas

Para saltar para ocorrências a partir do cursor para frente:

]<Ctrl-I>

Mudando de modo visual carácter/linha para bloco

2009-04-20T14:03:00.003-03:00

Se você está usando o modo visual carácter ou linha mas descobre que você deveria estar
usando o modo visual bloco use o comando:

<Ctrl-V>

para mudar rapidamente.

Copiando texto no modo visual

2009-04-20T14:01:00.001-03:00

O comando 'y' irá copiar o texto selecionado em um registrador. Enquanto que o comando 'Y' copiará linhas inteiras no registrador.

Opção para controlar o uso de janelas quando se muda de buffer

2009-04-20T13:24:00.006-03:00

A ação default do vim para os comandos 'split/buffer' (p.e :sbnext, :sbuffer
arquivo ,etc) é dividir a janela corrente e carregar o arquivo.
Usando a opção:

:set switchbuf=useopen

faz com que o Vim só salte para a primeira janela que contiver o buffer, se
existir.
Nota: você ainda pode dividir a janela para ver 2 visões do mesmo arquivo com
comandos ':split'.
Quando você roda o ':make' e ocorre erro, o Vim mostrará o arquivo com o
problema na janela corrente.
Se usar:

:set switchbuf=split

o editor dividirá a janela corrente mostrando o arquivo errado na nova janela.

Expressão regular: usando escape para caracteres especiais

2009-04-18T10:57:00.004-03:00

Se for pesquisar usando caracteres que são caracteres especiais de expressão
regular, eles devem ser precedidos pr backslash ('\').
Por exemplo,^, $,. portanto deve ser escapados com o backslash (\):

/lei\.

Expressão regular: Um carácter qualquer

2009-04-18T10:55:00.001-03:00

'.' corresponde a um carácter qualquer.
Pesquise por uma palavra que tenha um carácter qualquer (.):

/la.a

'la' seguido de um carácter qualquer seguido de 'a'

Mostrando qual idioma o Vim está usando

2009-04-17T14:14:00.001-03:00

Use:

:language

Layout portável de um arquivo de sintaxe

2009-04-17T12:12:00.002-03:00

Siga essas orientações para fazer arquivos de sintaxe acessíveis para todos.
Comece com um header que explique para que é o arquivo de sintaxe, quem o mantém
e quando foi sua última atualização. Não inclua muita informação sobre o
histórico de mudanças, poucas pessoas irão le-la.
Exemplo:

" Vim syntax file
" Language:     C
" Maintainer:   Bram Moolenaar <Bram@vim.org>
" Last Change: 2001 Jun 18
" Remark:       Included by the C++ syntax.

Use o mesmo layout que os outros arquivos de sintaxe. Usar um arquivo de sintaxe
existente irá lhe economizar um monte de tempo.

Escolha um bom e descritivo nome para seu arquivo de sintaxe. Use letras
minusculas e dígitos. Não faça-o muito longo, ele é usado em muitos lugares: O
nome do arquivo de sintaxe 'nome.vim', 'filetype', use 'b:current_syntax' no início
de cada grupo de sintaxe (nameType, nameStatement, nameString, etc).

Comece com um teste do 'b:current_syntax'. Se estiver definido, algum outro
arquivo de sintaxe, mais no início do 'runtimepath' já foi carregado:

if exists("b:current_syntax")
    finish
endif

Para ser compatível com o Vim 5.8 use:

if version < 600
  syntax clear
elseif exists("b:current_syntax")
  finish
endif

Defina 'b:current_syntax' para o nome da sintaxe no final. Não esqueça que
arquivos incluídos fazem isto também, você pode ter que redefinir
'b:current_syntax' se você incluir dois arquivos.

Se você quiser que seu arquivo de sintaxe funcione com Vim 5.x, adicione um
teste do v:version. Veja 'yacc.vim' por um exemplo.

Não inclua qualquer coisa que é uma preferencia do usuário. Não, define
'tabstop', 'expandtab', etc. Estes pertencem ao filetype plugin.

Não inclua mapeamentos ou abreviaçoes. Somente inclua a definição de 'iskeyword'
se for realmente necessária para reconhecimento de palavras-chave.

Para permitir que os próprios usuários selecionem sua cores preferidas, faça um
nome de grupo diferente para cada tipo de item colorizado. Então associe cada um
deles para um dos grupos de colorização padrão. Isto fará com que trabalhe com
qualquer esquema de cores.
Se você selecionar cores específicas ele irá parecer ruim com alguns esquemas de
cores. E não esqueça que algumas pessoas usam uma cor de fundo diferente, ou só
tem oito cores disponíveis.

Para a associação use 'hi def link', para que o usuário possa selecionar
colorização diferente antes que seu arquivo de sintaxe seja carregado. Exemplo:

hi def link nameString  String
hi def link nameNumber  Number
hi def link nameCommand Statement
          ... etc ...

Adicione o argumento 'display' para itens que não serão usados quando
sincronizando, para acelerar a rolagem para trás e o Ctrl-L.

Adicionando novos itens a um arquivo de sintaxe existente

2009-04-17T11:13:00.002-03:00

Quando um arquivo de sintaxe já existe, mas está faltando alguns itens, você
pode adiciona-los em um arquivo separado.

Isto evita mudar o arquivo de sintaxe distribuído, o qual seria perdido quando
instalando uma nova versão do Vim.

Grave os comandos de sintaxe em seu arquivo, possivelmente usando nomes de
grupos da sintaxe existente. Por exemplo, para adicionar novos tipos de
variáveis para o arquivo de sintaxe C:

:syntax keyword cType off_t uint

Grave o arquivo com o mesmo nome que o arquivo de sintaxe original. Neste caso
'c.vim'.
Coloque-o em um diretório próximo ao final do 'runtimepath'. Isto faz que seja
carregado depois do arquivo de sintaxe original. No Unix seria:

~/.vim/after/syntax/c.vim

Instalando um novo arquivo de sintaxe

2009-04-17T10:36:00.002-03:00

Quando seu arquivo de sintaxe estiver pronto, jogue-o em um diretório 'syntax'
no 'runtimepath'. No Unix, isso seria '~/.vim/syntax'.
O nome do arquivo de sintaxe deveria ser igual ao tipo do arquivo, com '.vim'
adicionado. Assim para a linguagem 'x', o path completo do arquivo seria:

~/.vim/syntax/x.vim

Você também deve fazer o tipo do arquivo ser conhecido.

Se o seu arquivo funciona bem, você poderia querer que ele estivesse disponível
para outros usuários Vim.
Após testar bem o arquivo, passe-o por e-mail ao manutendor do Vim:
<maintainer@vim.org>. Também explique como o tipo do arquivo pode ser detectado.
Com um pouco de sorte seu arquivo pode ser incluído na próxima versão do Vim.

Definindo como será sincronizada a tela no arquivo de sintaxe

2009-04-17T08:44:00.005-03:00

Os compiladores analisam um arquivo a partir do início. Para o Vim é mais complicado pois deve começar no meio aonde a edição está sendo feita. Então, como ele sabe aonde ele está?

O segredo é o comando ':syntax sync'. Ele diz ao Vim como descobrir aonde está.
Por exemplo, o comando seguinte diz ao Vim para procurar atrás pelo início
ou fim de um comentário no estilo C e começar a colorização de sintaxe a partir
de lá:

:syntax sync ccomment

Você pode ajustar este processamento com alguns argumentos. O argumento
'minlines' diz ao Vim o número mínimo de linhas para procurar atrás, e
'maxlines' diz ao editor o número máximo de linhas para pesquisar.

Por exemplo, o seguinte comando diz ao Vim para olhar 10 linhas antes do topo da
tela:

:syntax sync ccomment minlines=10 maxlines=500

Se ele não consegue descobrir aonde ele está naquele espaço, ele começa olhar
mais e mais para atrás até que ele descubra o que fazer. Mas ele não olha atrás não mais que 500 linhas. (Um 'maxlines' grande torna lento o processamento. Um
valor pequeno pode causar a sincronização falhar.)

Para fazer a sincronização um pouco mais rápida, diga ao Vim quais itens de
sintaxe que podem ser pulados. Todo 'match' e 'region' que somente precisa ser usado
quando estiver realmente mostrando o texto pode ser dado o argumento 'display'.

Por default, o comentário a ser encontrado será colorizado como parte do grupo
de sintaxe 'Comment'. Se você colorizar as coisas de outro modo, você pode
especificar um outro grupo de sintaxe:

:syntax sync ccomment xAltComment

Se sua linguagem de programação não tem comentários estilo C dentro dele, você
pode tentar outro modo de sincronização. O modo mais simples é dizer ao Vim para
retornar um número de linhas e tentar descobrir as coisas a partir de lá.
O seguinte comando diz ao Vim para voltar atraś 150 linhas e começar a analisar a
partir de lá:

:syntax sync minlines=150

O valor grande de 'minlines' pode fazer o Vim ficar lento, especialmente quando percorrendo o arquivo para trás.
Finalmente, você pode especificar um grupo de sintaxe a ser procurado usando
este comando:

:syntax sync match {sync−group−name}
        \ grouphere {group−name} {pattern}

Isto diz ao Vim que quando ele ver o {pattern} o grupo de sintaxe chamado de {group-name} começa exatamente depois do padrão dado.

O {sync−group−name} é usado para dar um nome para essa especificação de
sincronização. Por exemplo, a linguagem de script 'sh' começa com um comando

if [ −−f file.txt ] ; then ~
        echo "File exists" ~
fi

Para definir um diretiva 'grouphere' para esta sintaxe, você usa o seguinte
comando:

:syntax sync match shIfSync grouphere shIf "\<if\>"

O argumento 'grouphere' diz ao Vim que o padrão termina o grupo. Por exemplo, o
fim do grupo 'if/fi' é o seguinte:

:syntax sync match shIfSync groupthere NONE "\<fi\>"

Neste exemplo, o 'NONE' diz ao Vim que você não está em nenhum região especial
de sintaxe. Em particular, você não está num bloco 'if'.

Você pode também definir matches e regions sem nenhum argumento 'grouphere' ou
'groupthere'.

Estes grupos são para grupos de sintaxe pulados durante a sincronização. Por
exemplo, o seguinte comando pula pula sobre qualquer coisa dentro de '{}', mesmo se ele normalmente correspondesse com outro método de sincronização:
:syntax sync match xSpecial /{.*}/

Incluindo um arquivo de sintaxe dentro de outro

2009-04-16T21:10:00.010-03:00

A linguagem C++ é um superconjunto da linguagem C. Como você não vai querer criar dois arquivos de sintaxe, você pode colocar o arquivo de sintaxe do C++ dentro do C com o seguinte comando:

:runtime! syntax/c.vim

O comando ':runtime!' procura no 'runtimepath' por todos arquivos 'syntax/c.vim'.
Isto faz a sintaxe C++ ser definida parecida com os arquivos C.

Se você mudou o arquivo de sintaxe 'c.vim', ou adicionou itens com um arquivo
extra, estes serão carregados também.

Depois de carregados os itens de sintaxe C os itens específicos de C++ podem ser
definidos. Por exemplo, adicionar palavras-chave que não são usadas no C:

:syntax keyword cppStatement new delete this friend using

Isto funciona exatamente como qualquer outro arquivo de sintaxe.

Agora considere a linguagem Perl. Ela consiste de duas partes distintas: um
parte de documentação no formato POD, e um programa escrito no próprio Perl.

A seção POD começa com '=head' e termina com '=cut'.
Você quer definir a sintaxe POD em um arquivo, e usa-lo a partir do arquivo
de sintaxe do Perl.

Para o Perl, os comandos são :

:syntax include @Pod <sfile>:p:h/pod.vim
:syntax region perlPOD start=/^=head/ end=/^=cut/ contains=@Pod

Quando '=head' é encontrado em um arquivo Perl, a região 'PerlPOD' começa.
Nesta região o cluster @POD está contido. Todos os itens definidos como itens
nível do topo nos arquivos de sintaxe 'pod.vim' serão localizados aqui. Quando
'=cut' é encontrado, a região termina e nos voltamos para os itens definidos
para o arquivo Perl.

O comando ':syntax include' é esperto o suficiente para ignorar um comando
':syntax clear' no arquivo incluído. E um argumento tal como 'contains=all'
somente conterão itens definidos no arquivo incluído, não no arquivo que o
inclui.

A parte ':p:h/' usa o nome do arquivo corrente (<sfile>), o expande
o path completo (:p), e então tira a parte da frente (:head).

Isto resulta no nome do diretório do arquivo. Isto faz com que o arquivo 'pod.vim'
no mesmo diretório seja incluído.

Simplificando definições de item com clusters no arquivo de sintaxe

2009-04-16T19:08:00.001-03:00

Uma das coisas que você notará quando começar a escrever um arquivo de sintaxe
você acabará gerando um monte de grupos de sintaxe. O Vim permite que você
defina uma coleção de grupos de sintaxe chamada de 'cluster'.

Suponha que você tem uma linguagem que contém loops 'for', comandos 'if', loops
'while', e funções. Cada uma delas contém os mesmos elementos de sintaxe:
números e identificadores. Você define-os assim:

:syntax match xFor /^for.*/ contains=xNumber,xIdent
:syntax match xIf /^if.*/ contains=xNumber,xIdent
:syntax match xWhile /^while.*/ contains=xNumber,xIdent

Você tem que repetir a mesma clausula 'contains=' a cada vez. Se você quiser
adicionar outro item contido, você tem que adiciona-lo três vezes. Os clusters
de sintaxe simplificam esta definições ao permitir que você tenha um cluster
pronto para diversos grupos de sintaxe.

Para definir um cluster para os dois itens que os três grupos contém, use o
seguinte comando:

:syntax cluster xState contains=xNumber,xIdent

Os clusters são usados dentro de outros itens de sintaxe exatamente como
qualquer outro grupo de sintaxe.
Seus nomes começam com '@'. Assim, você pode definir os três grupos assim:

:syntax match xFor /^for.*/ contains=@xState
:syntax match xIf /^if.*/ contains=@xState
:syntax match xWhile /^while.*/ contains=@xState

Você pode adicionar novos nomes de grupo para este cluster com o argumento
'add':

:syntax cluster xState add=xString

Você pode remover grupos de sintaxe desta lista também:

:syntax cluster xState remove=xNumber

Definindo item com ou sem linha de continuação no arquivo de sintaxe

2009-04-16T13:50:00.003-03:00

Vamos definir uma linha de um preprocessador.
Isto começa com um '#' na primeira coluna e segue até o final da linha. Uma
linha que termina com '\' faz a próxima linha ser uma linha de continuação.

O modo que você trata isso é permitindo o item de sintaxe conter um padrão de
continuação:

:syntax region xPreProc start=/^#/ end=/$/ contains=xLineContinue
:syntax match xLineContinue "\\$" contained

Neste caso, embora 'xPreProc' normalmente normalmente obtém um única linha, o
grupo contido nele (chamado de 'xLineContinue') permite-o ir para mais de uma
linha.
Por exemplo, ele irá localizar ambas dessas linhas:

#define SPAM spam spam spam \ ~
               bacon and spam ~

Neste caso, isto é o que você quer. Se não é isso que você quer, você pode pedir
para que a região esteja em uma única linha adicionando 'excludenl' para o
padrão contido.
Por exemplo, você quer colorir 'end' em 'xPreProc', mas somente no final da
linha.
Para evitar que 'xPreProc' continue na próxima linha, como 'xLineContinue' faz,
use 'excludenl' assim:

:syntax region xPreProc start=/^#/ end=/$/
        \ contains=xLineContinue,xPreProcEnd
:syntax match xPreProcEnd excludenl /end$/ contained
:syntax match xLineContinue "\\$" contained

'excludenl' deve ser posto antes do padrão. Desde que 'xLineContinue' não tem
'excludenl', um ocorrência dele estende 'xPreProc' para a próxima linha como
antes.

Definindo uma região que não ultrapasse uma linha no arquivo de sintaxe.

2009-04-16T13:39:00.001-03:00

O argumento 'oneline' indica que a região não cruza um limite de linha.
Por exemplo:

:syntax region xIfThen start=/if/ end=/then/ oneline

Isto define uma região que começa em um 'if' e termina em um 'then'. Mas se não
existe nenhum 'then' após o 'if', a região não obtém uma ocorrência.

Nota:
Quando usando 'oneline' a região não começa se o padrão 'end' não obtém
ocorrência na mesma linha. Sem 'oneline' o Vim não verifica se existe uma
ocorrência para o padrão 'end'. A região começa mesmo que o padrão 'end' não
obtém ocorrência no resto do arquivo.

Definindo colorização de item por deslocamentos na região no arquivo de sintaxe

2009-04-16T12:26:00.002-03:00

Suponha que você quer definir um região para o texto entre '(' e ')' depois de
um 'if'.
Mas você não quer incluir o 'if' ou o '(' e ')'. Você pode fazer isso
especificando 'offsets' (deslocamentos) para os padrões:

:syntax region xCond start=/if\s*(/ms=e+1 end=/)/me=s−1

O deslocamento para o padrão 'start' é 'ms=e+1'. 'ms' significa 'Match Start'. Isto
define um deslocamento para o início da ocorrência do texto. Normalmente a
ocorrência começa aonde o padrão localiza. 'e+1' significa que a ocorrência
agora começa no final que o padrão localizou, e então um carácter a mais.
O deslocamento para o final do padrão é 'me=s-1'. 'me' significa 'Match End'.
's-1' significa o início que o padrão localizou e então um carácter a menos.
O resultado neste texto :

if (foo == bar)

Somente 'foo == bar' será colorizado como 'xCond'.

Definindo um item com a colorização do item que o contém no arquivo de sintaxe

2009-04-16T10:09:00.003-03:00

Em um arquivo na linguagem C você gostaria de colorir o texto '()' depois de um
'while' diferente do texto '()' depois de 'for'.

Em ambos casos, podem existir itens '()' aninhados, os quais deveriam ser
coloridos do mesmo modo.

Você deve ter certeza que a colorização pare no ')' correspondente.
Este é um modo de fazer isso:

:syntax region cWhile matchgroup=cWhile start=/while\s*(/ end=/)/
        \ contains=cCondNest
:syntax region cFor matchgroup=cFor start=/for\s*(/ end=/)/
        \ contains=cCondNest
:syntax region cCondNest start=/(/ end=/)/ contained transparent

Agora você pode dar 'cWhile' e 'cFor' uma colorização diferente. 'cCondNest'
pode aparecer em qualquer um deles, mas ele leva a colorização do item em que
está contido.
O argumento 'transparent' faz isso.

Note que o argumento 'matchgroup' tem o mesmo grupo que o próprio item. Porque
defini-lo então? O efeito secundário de usar um 'matchgroup' é que os itens
contidos não são encontrados encontrados no padrão com o item 'start'.

Isto evita que o grupo 'cCondNest' encontre o '(' bem após o 'while' ou o 'for'.
Se isto tivesse acontecido, ele iria se expandir o texto todo até encontrar ')'
e a região continuaria após ele.

Agora 'cCondNest' somente irá localizar após o padrão start, assim depois do primeiro '('.

Definindo a colorização de itens diferente da região que os contém em um arquivo de sintaxe

2009-04-15T18:49:00.007-03:00

Quando você define uma região, a região inteira é colorida de acordo com o nome
do grupo especificado.
Para colorir o texto entre parenteses com o grupo 'xInside', por exemplo, use o
seguinte comando:

:syntax region xInside start=/(/ end=/)/

Suponha que você quer colorir os parenteses de modo diferente. Você pode fazer isso
com um monte de comandos 'region' misturados, ou pode usar o argumento
'matchgroup'.

O código a seguir, diz ao Vim para colorir o início e fim de uma região com um grupo de
colorização diferente (neste caso, o grupo 'xParen'):

:syntax region xInside matchgroup=xParen start=/(/ end=/)/

O argumento 'matchgroup' aplica aos padrões 'start' ou 'end' que vem depois dele.
No exemplo anterior, tanto 'start' ou 'end' são coloridos com 'xParen'. Para
colorir o final com 'xParenEnd':

:syntax region xInside matchgroup=xParen start=/(/
        \ matchgroup=xParenEnd end=/)/

Um efeito secundário de usar 'matchgroup' é que os itens contidos não serão
localizados no início ou fim da região.