2004-05-14 07:12:29 +00:00
|
|
|
|
Copyright (c) 2004 Free Software Foundation, Inc; Veja no fim as
|
|
|
|
|
condi<EFBFBD><EFBFBD>es.
|
|
|
|
|
|
|
|
|
|
Os comandos do Emacs geralmente envolvem a tecla CONTROL (algumas vezes
|
|
|
|
|
nomeada CTRL ou CTL) ou a tecla META (algumas vezes nomeada EDIT ou
|
|
|
|
|
ALT). Antes de escrever isso tudo toda vez, usaremos as seguintes
|
|
|
|
|
abrevia<EFBFBD><EFBFBD>es:
|
|
|
|
|
|
|
|
|
|
C-<chr> Significa pressionar a tecla CONTROL enquanto digitar o
|
|
|
|
|
caracter <chr>
|
|
|
|
|
Assim, C-f seria: Pressionar a tecla CONTROL e digitar f.
|
|
|
|
|
M-<chr> Significa pressionar a tecla META, EDIT ou ALT enquanto
|
|
|
|
|
digitar <chr>.
|
|
|
|
|
Se n<>o tiver META, EDIT ou ALT, no lugar digite ESC e depois
|
|
|
|
|
<chr>. Escrevemos <ESC> para tecla ESC.
|
|
|
|
|
|
|
|
|
|
|
2004-05-16 06:33:53 +00:00
|
|
|
|
Nota importante: para terminar a se<73><65>o do Emacs, digite C-x C-c. (Dois
|
2004-05-14 07:12:29 +00:00
|
|
|
|
caracteres.) Os caracteres ">>" na margem esquerda indicam dire<72><65>es para
|
|
|
|
|
voc<EFBFBD> tentar usar um comando. Por exemplo:
|
|
|
|
|
<<Linhas vazias inseridas ao redor da linha seguinte por
|
|
|
|
|
ajuda-com-tutorial>>
|
|
|
|
|
[Metade da p<>gina em branco para prop<6F>sitos did<69>ticos. O texto continua
|
|
|
|
|
abaixo]
|
|
|
|
|
>> Agora digite C-v (Ver pr<70>xima tela) para ir para pr<70>xima tela.
|
|
|
|
|
(v<> em frente, fa<66>a isso pressionando a tecla CONTROL enquanto
|
|
|
|
|
digitar v).
|
|
|
|
|
De agora em diante, voc<6F> deve fazer isso de novo sempre que voc<6F>
|
|
|
|
|
terminar de ler a tela.
|
|
|
|
|
|
|
|
|
|
Note que tem uma sobreposi<73><69>o de duas linhas quando voc<6F> move de tela em
|
|
|
|
|
tela; isso fornece uma continuidade para que voc<6F> continue lendo o
|
|
|
|
|
texto.
|
|
|
|
|
|
|
|
|
|
A primeira coisa que voc<6F> precisa saber <20> como se mover de um lugar a
|
|
|
|
|
outro no texto. Voc<6F> j<> sabe como se mover para pr<70>xima tela, com
|
|
|
|
|
C-v. Para se mover para tr<74>s uma tela, digite M-v (pressione a tecla
|
|
|
|
|
META enquanto digita v, ou digite <ESC>v se voc<6F> n<>o tiver a tecla META,
|
|
|
|
|
EDIT ou ALT).
|
|
|
|
|
|
|
|
|
|
>> Tente digitar M-v e depois C-v, algumas vezes.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* SUM<55>RIO
|
|
|
|
|
---------
|
|
|
|
|
|
|
|
|
|
Os comandos a seguir s<>o <20>teis para visualizar telas inteiras
|
|
|
|
|
|
|
|
|
|
C-v Move para tela inteira posterior
|
|
|
|
|
M-x Move para tela inteira anterior
|
|
|
|
|
C-l Limpa a tela e re-mostra todo o texto, movendo o texto ao
|
|
|
|
|
redor do cursor para o centro da tela. (Isso <20>
|
|
|
|
|
control-L, n<>o control-1.)
|
|
|
|
|
|
|
|
|
|
>> Encontre o cursor, e note o texto que est<73> perto dele.
|
|
|
|
|
Digite C-l.
|
|
|
|
|
Encontre o cursor novamente e perceba que o mesmo texto continua
|
|
|
|
|
perto do cursor.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* CONTROLE B<>SICO DO CURSOR
|
|
|
|
|
---------------------------
|
|
|
|
|
|
|
|
|
|
Movendo de uma tela inteira para outra tela cheia <20> <20>til, mas como voc<6F>
|
|
|
|
|
move para um lugar especifico com o mesmo texto na tela?
|
|
|
|
|
|
|
|
|
|
Existem diversas maneiras para voc<6F> poder fazer isso. A maneira mais
|
|
|
|
|
b<EFBFBD>sica <20> utilizar os comandos C-p, C-b, C-f e C-n. Cada um desses
|
|
|
|
|
comandos movem o cursor uma linha ou coluna na tela em uma dire<72><65>o
|
|
|
|
|
particular. Aqui est<73> uma tabela mostrando esses quatro comandos e as
|
|
|
|
|
dire<EFBFBD><EFBFBD>es que eles movem:
|
|
|
|
|
|
|
|
|
|
Linha anterior, C-p
|
|
|
|
|
:
|
|
|
|
|
:
|
|
|
|
|
Traz, C-b .... Posi<73><69>o corrente do cursor .... Frente, C-f
|
|
|
|
|
:
|
|
|
|
|
:
|
|
|
|
|
Linha posterior, C-n
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para a linha no meio do diagrama acima utilizando C-n
|
|
|
|
|
ou C-p. Digite C-l para ver o diagrama inteiro centralizado na tela.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> provavelmente achar<61> isso f<>cil pensando neles pela letra: P para
|
|
|
|
|
Previous (anterior), N para Next (Posterior), B para Backward (tr<74>s) e F
|
|
|
|
|
para forward (frente). Estes s<>o os comandos b<>sicos de posicionamento
|
|
|
|
|
de cursor e voc<6F> estar<61> utilizando eles a TODO tempo, ent<6E>o seria <20>timo
|
|
|
|
|
se voc<6F> os aprendesse agora.
|
|
|
|
|
|
|
|
|
|
>> Fa<46>a alguns C-n's para trazer o cursor abaixo desta linha.
|
|
|
|
|
|
|
|
|
|
>> Mova para a linha com C-f's e depois para cima com C-p's.
|
|
|
|
|
Veja o que C-p faz quando o cursor est<73> no meio da linha.
|
|
|
|
|
|
|
|
|
|
Cada linha de texto termina com um caractere de nova linha, que serve
|
|
|
|
|
para separar da pr<70>xima linha. No fim da ultima linha deve ter um
|
|
|
|
|
caractere de nova linha (mas n<>o <20> exigido pelo Emacs).
|
|
|
|
|
|
|
|
|
|
>> Tente digitar C-b no come<6D>o da linha. O cursor deve mover para o fim
|
|
|
|
|
da linha anterior. Isso acontece por que ele se moveu para tr<74>s
|
|
|
|
|
atrav<61>s do caractere de nova linha.
|
|
|
|
|
|
|
|
|
|
C-f pode mover o cursor atrav<61>s de uma Nova linha do mesmo jeito que
|
|
|
|
|
C-b.
|
|
|
|
|
|
|
|
|
|
>> Fa<46>a mais alguns C-b's, assim voc<6F> percebe onde o est<73> o cursor.
|
|
|
|
|
Depois alguns C-f's para retornar para o fim da linha.
|
|
|
|
|
Depois mais um C-f para mover para linha seguinte.
|
|
|
|
|
|
|
|
|
|
Quando voc<6F> move o cursor passando o topo ou o rodap<61> da tela, o pr<70>ximo
|
|
|
|
|
texto al<61>m da borda desloca-se na tela. Isso <20> chamado rolagem. Isso
|
|
|
|
|
ativa o Emacs para mover o cursor para o lugar especificado no texto sem
|
|
|
|
|
move-lo fora da tela.
|
|
|
|
|
|
|
|
|
|
>> Tente mover o cursor fora do rodap<61> da tela com C-n, e veja o que
|
|
|
|
|
acontece.
|
|
|
|
|
|
|
|
|
|
Se mover por caracteres <20> muito lento, voc<6F> pode se mover por
|
|
|
|
|
palavras. M-f (Meta-f) move uma palavra para frente e M-b uma palavra
|
|
|
|
|
para tr<74>s.
|
|
|
|
|
|
|
|
|
|
>> Digite alguns M-f's e M-b's
|
|
|
|
|
|
|
|
|
|
Quando voc<6F> est<73> no meio de uma palavra, M-f move o cursor para o fim da
|
|
|
|
|
mesma. Quando voc<6F> est<73> em um espa<70>o em branco no meio de duas palavras,
|
|
|
|
|
M-f move o cursor para o fim da palavra seguinte. M-b funciona do mesmo
|
|
|
|
|
jeito na dire<72><65>o contraria.
|
|
|
|
|
|
|
|
|
|
>> Digite M-f e M-b algumas vezes, intercalado com C-f's e C-b's assim
|
|
|
|
|
voc<6F> pode observar a a<><61>o do M-f e M-b de varias lugares dentro e no
|
|
|
|
|
meio de palavras.
|
|
|
|
|
|
|
|
|
|
Observe o paralelismo entre C-f e C-b em uma m<>o, e M-f e M-b na
|
|
|
|
|
outra. Muito freq<65>entemente os caracteres Meta s<>o usados para opera<72><61>es
|
|
|
|
|
relacionadas com as unidades definidas pela linguagem (palavras,
|
|
|
|
|
senten<EFBFBD>as, par<61>grafos), enquanto caracteres Control operam nas unidades
|
|
|
|
|
b<EFBFBD>sicas que s<>o independente do que voc<6F> est<73> editando (caracteres,
|
|
|
|
|
linhas, etc).
|
|
|
|
|
|
|
|
|
|
Esse paralelismo aplica-se entre linhas e senten<65>as: C-a e C-e move o
|
|
|
|
|
cursor para o come<6D>o ou fim da linha, e M-a e M-e move o cursor para o
|
|
|
|
|
come<EFBFBD>o ou fim da senten<65>a.
|
|
|
|
|
|
|
|
|
|
>> Tente alguns C-a's, e depois alguns C-e's.
|
|
|
|
|
Tente alguns M-a's, e depois alguns M-e's.
|
|
|
|
|
|
|
|
|
|
Veja como repetidos C-a's fazem nada, mas repetidos M-a's mant<6E>m movendo
|
|
|
|
|
mais uma senten<65>a. Embora estes n<>o sejam completamente an<61>logos, cada
|
|
|
|
|
um parece natural.
|
|
|
|
|
|
|
|
|
|
A posi<73><69>o do cursor no texto <20> tamb<6D>m chamado "ponto" (point). Para
|
|
|
|
|
parafrasear, o cursor mostra na tela onde o ponto <20> encontrado no texto.
|
|
|
|
|
|
|
|
|
|
Aqui est<73> um simples sum<75>rio das opera<72><61>es de movimento de cursor,
|
|
|
|
|
incluindo comandos de movimento de palavra e senten<65>a.
|
|
|
|
|
|
|
|
|
|
C-f Move o cursor um caractere para frente
|
|
|
|
|
C-b Move o cursor um caractere para tr<74>s
|
|
|
|
|
|
|
|
|
|
M-f Move o cursor uma palavra para frente
|
|
|
|
|
M-b Move o cursor uma palavra para tr<74>s
|
|
|
|
|
|
|
|
|
|
C-n Move o cursor para linha posterior
|
|
|
|
|
C-p Move o cursor para linha anterior
|
|
|
|
|
|
|
|
|
|
C-a Move o cursor para o come<6D>o da linha
|
|
|
|
|
C-e Move o cursor para o fim da linha
|
|
|
|
|
|
|
|
|
|
M-a Move o cursor para tr<74>s no come<6D>o da senten<65>a
|
|
|
|
|
M-e Move o cursor para frente no fim da senten<65>a
|
|
|
|
|
|
|
|
|
|
>> Tente agora todos estes comandos algumas vezes para praticar.
|
|
|
|
|
Estes s<>o os comandos mais utilizados.
|
|
|
|
|
|
|
|
|
|
Outros dois comandos de movimento de cursor importantes s<>o M-< (Meta
|
|
|
|
|
Menor-que), o qual move o cursor para o come<6D>o de todo o texto, e M->
|
|
|
|
|
(Meta Maior-que), o qual move para o fim de todo o texto.
|
|
|
|
|
|
|
|
|
|
Na maioria dos terminais, o "<" <20> acima da v<>rgula, ent<6E>o voc<6F> precisa
|
|
|
|
|
utilizar a tecla shift para digita-la. Nestes terminais voc<6F> precisa
|
|
|
|
|
utilizar a tecla shift para digitar M-< tamb<6D>m; sem a tecla shift, voc<6F>
|
|
|
|
|
estaria teclando M-virgula.
|
|
|
|
|
|
|
|
|
|
>> Tente agora M-<, para mover o cursor ao come<6D>o do tutorial.
|
|
|
|
|
Use ent<6E>o C-v repetidamente para trazer o cursor novamente aqui.
|
|
|
|
|
|
|
|
|
|
>> Tente agora M->, para mover o cursor ao fim do tutorial.
|
|
|
|
|
Use ent<6E>o M-v repetidamente para trazer o cursor novamente aqui.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> tamb<6D>m pode mover o cursor com as setas, se o seu terminal tem
|
|
|
|
|
teclas com setas. N<>s recomendamos aprender C-b, C-f, C-n e C-p por tr<74>s
|
|
|
|
|
raz<EFBFBD>es. Primeira, elas funcionam em todos os terminais. Segunda, uma vez
|
|
|
|
|
que voc<6F> ganhar pr<70>tica usando o Emacs, voc<6F> descobrir<69> que digitar
|
|
|
|
|
nestes caracteres Control <20> mais r<>pido do que digitar nas setas (porque
|
|
|
|
|
voc<EFBFBD> n<>o tem que mover suas m<>os t<>o longe da posi<73><69>o de
|
|
|
|
|
digita<EFBFBD><EFBFBD>o). Terceira, uma vez que voc<6F> tiver o h<>bito de utilizar estes
|
|
|
|
|
comandos de caracteres Control, voc<6F> pode facilmente aprender como usar
|
|
|
|
|
outros comandos avan<61>ados de movimenta<74><61>o do cursor.
|
|
|
|
|
|
|
|
|
|
A maioria dos comandos do Emacs aceitam argumentos num<75>ricos; para
|
|
|
|
|
maioria dos comandos, isso serve como um fator de repeti<74><69>o. A maneira
|
|
|
|
|
que voc<6F> da a um comando uma repeti<74><69>o teclando C-u e depois os d<>gitos
|
|
|
|
|
antes de digitar o comando. Se voc<6F> tem o META (EDIT ou ALT), tem outra
|
|
|
|
|
alternativa para digitar um argumento num<75>rico: digite os d<>gitos
|
|
|
|
|
enquanto pressionando a tecla META. N<>s recomendamos aprender o m<>todo
|
|
|
|
|
C-u porque funciona em todos os terminais. O argumento num<75>rico tamb<6D>m <20>
|
|
|
|
|
chamado de "argumento prefixo", porque voc<6F> digita o argumento antes do
|
|
|
|
|
comando que ele se aplica.
|
|
|
|
|
|
|
|
|
|
Por exemplo, C-u 8 C-f move o cursor oito caracteres para frente
|
|
|
|
|
|
|
|
|
|
>> Tente usar C-n ou C-p com um argumento num<75>rico, para mover o
|
|
|
|
|
cursor para um linha perto dessa com um <20>nico comando.
|
|
|
|
|
|
|
|
|
|
A maioria dos comandos usam o argumento num<75>rico para um fator de
|
|
|
|
|
repeti<EFBFBD><EFBFBD>o, mas alguns comandos usam isso de outra maneira. Diversos
|
|
|
|
|
comandos (mas nenhum daqueles comandos que voc<6F> tenha aprendido at<61>
|
|
|
|
|
agora) usam isso como uma marca -- a presen<65>a de um argumento prefixo,
|
|
|
|
|
independente do seu valor, faz o comando fazer alguma coisa diferente.
|
|
|
|
|
|
|
|
|
|
C-v e M-v s<>o outro tipo de exce<63><65>o. Quando voc<6F> da um argumento, eles
|
|
|
|
|
rolam a tela para cima ou para baixo por aquele n<>mero de linhas, de
|
|
|
|
|
prefer<EFBFBD>ncia com a tela cheia. Por exemplo, C-u 8 C-v rola a tela 8
|
|
|
|
|
linhas.
|
|
|
|
|
|
|
|
|
|
>> Tente agora digitar C-u 8 C-v.
|
|
|
|
|
|
|
|
|
|
Isso deve ter rolado a tela para cima 8 linhas. Se voc<6F> quiser rolar a
|
|
|
|
|
tela para baixo novamente, voc<6F> pode dar um argumento para o M-v.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> est<73> usando um display com janelas, como o X11 ou MS-Windows,
|
|
|
|
|
deve ter uma <20>rea retangular alta chamada barra de rolagem na m<>o
|
|
|
|
|
esquerda da janela do Emacs. Voc<6F> pode rolar o texto clicando o mouse na
|
|
|
|
|
barra de rolagem.
|
|
|
|
|
|
|
|
|
|
>> Tente pressionar o bot<6F>o do meio no topo da <20>rea destacada junto a
|
|
|
|
|
barra de rolagem. Isso deve rolar o texto para uma determinada
|
|
|
|
|
posi<73><69>o dependendo de qu<71>o alto ou baixo voc<6F> clicar.
|
|
|
|
|
|
|
|
|
|
>> Tente mover o mouse para cima e para baixo, enquanto pressionar o
|
|
|
|
|
bot<6F>o do meio. Voc<6F> ver<65> que o texto rolar<61> para cima e baixo assim
|
|
|
|
|
que voc<6F> mover o mouse.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* QUANDO O EMACS PARECE MORTO
|
|
|
|
|
-----------------------------
|
|
|
|
|
|
|
|
|
|
Se o Emacs parar de responder os seus comandos, voc<6F> pode seguramente
|
|
|
|
|
para-lo digitando C-g. Voc<6F> pode utilizar C-g para parar um comando que
|
|
|
|
|
est<EFBFBD> levando muito tempo para executar.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> tamb<6D>m pode utilizar C-g para interromper um argumento num<75>rico ou
|
|
|
|
|
o inicio de um comando que voc<6F> n<>o quer terminar.
|
|
|
|
|
|
|
|
|
|
>> Digite C-u 100 para fazer um argumento num<75>rico de 100, e depois
|
|
|
|
|
digite C-g. Agora digite C-f. O Cursor deve mover apenas um
|
|
|
|
|
caractere, porque voc<6F> cancelou o argumento com C-g.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> digitou um <ESC> por engano, voc<6F> pode sair dele com um c-g.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* COMANDOS DESABILITADOS
|
|
|
|
|
------------------------
|
|
|
|
|
|
|
|
|
|
Alguns comandos do Emacs s<>o "desabilitados" para que os usu<73>rios
|
|
|
|
|
iniciantes n<>o utilizem por acidente.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> digita um dos comandos desabilitados, o Emacs mostrar<61> uma
|
|
|
|
|
mensagem dizendo qual comando foi, e pergunta se voc<6F> quer seguir e
|
|
|
|
|
executar o comando.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> realmente quiser tentar o comando, digite Espa<70>o na resposta da
|
|
|
|
|
pergunta. Normalmente, se voc<6F> n<>o quer executar o comando desabilitado,
|
|
|
|
|
responda a pergunta com "n".
|
|
|
|
|
|
|
|
|
|
>> Digite C-x C-l (que <20> um comando desabilitado),
|
|
|
|
|
e ent<6E>o digite n para responder a pergunta.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* JANELAS
|
|
|
|
|
---------
|
|
|
|
|
|
|
|
|
|
O Emacs pode ter diversas janelas, cada uma mostrando seu pr<70>prio
|
|
|
|
|
texto. N<>s vamos explicar mais tarde como utilizar estas m<>ltiplas
|
|
|
|
|
janelas. Neste momento nos queremos explicar como se livrar das janelas
|
|
|
|
|
extras e voltar a edi<64><69>o b<>sica em uma janela. <20> simples:
|
|
|
|
|
|
|
|
|
|
C-x 1 Uma janela (mate todas as outras janelas).
|
|
|
|
|
|
|
|
|
|
Isto <20> Control-x seguido pelo digito 1. C-x 1 expande a janela que est<73>
|
|
|
|
|
com o cursor, para ocupar a tela inteira. Ela deleta todas as outras
|
|
|
|
|
janelas.
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para esta linha e digite C-u 0 C-l.
|
|
|
|
|
>> Digite Control-h k Control-f.
|
|
|
|
|
Veja como esta janela diminui, enquanto uma nova aparece para mostrar
|
|
|
|
|
a documenta<74><61>o do comando Control-f.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x 1 e veja a listagem de documenta<74><61>o desaparecer.
|
|
|
|
|
|
|
|
|
|
Este comando <20> diferente dos outros que voc<6F> aprendeu por isso ele
|
|
|
|
|
consiste em dois caracteres. Ele inicia com o caractere Control-x. Tem
|
|
|
|
|
uma grande serie de comandos que iniciam com Control-x; a maioria deles
|
|
|
|
|
tem a ver com janelas, arquivos, buffers, e coisas relacionadas. Estes
|
|
|
|
|
comandos tem dois, tr<74>s ou quatro caracteres de tamanho.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* INSERINDO E DELETANDO
|
|
|
|
|
-----------------------
|
|
|
|
|
|
|
|
|
|
Se voc<6F> quiser inserir um texto, apenas digite o texto. Os caracteres
|
|
|
|
|
que voc<6F> ver<65>, como A, 7, *, etc. s<>o vistos pelo Emacs como texto e s<>o
|
|
|
|
|
inseridos imediatamente. Digite <Return> para inserir um caractere de
|
|
|
|
|
nova linha.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode deletar o <20>ltimo caractere que voc<6F> inseriu digitando
|
|
|
|
|
<Delete>. <Delete> <20> uma tecla no teclado, que est<73> nomeado como
|
|
|
|
|
"Del". Em algumas casos, a tecla "Backspace" serve como o <Delete>, mas
|
|
|
|
|
nem sempre!
|
|
|
|
|
|
|
|
|
|
Mas geralmente, <Delete> deleta o caractere imediatamente anterior a
|
|
|
|
|
posi<EFBFBD><EFBFBD>o corrente do cursor.
|
|
|
|
|
|
|
|
|
|
>> Fa<46>a isso agora - Digite alguns caracteres, ent<6E>o delete eles
|
|
|
|
|
digitando <Delete> algumas vezes. N<>o se preocupe em modificar este
|
|
|
|
|
arquivo; voc<6F> n<>o ir<69> alterar o arquivo principal. Esta <20> a sua c<>pia
|
|
|
|
|
pessoal dele.
|
|
|
|
|
|
|
|
|
|
Quando uma linha de texto fica muito grande na tela, a linha do texto <20>
|
|
|
|
|
continuada na linha seguinte. Uma barra invertida ("\") na margem
|
|
|
|
|
direita indica a linha que foi continuada.
|
|
|
|
|
|
|
|
|
|
>> Insira texto at<61> que voc<6F> alcance a margem direita, e mantenha
|
|
|
|
|
inserindo. Voc<6F> ver<65> a linha de continua<75><61>o aparecer.
|
|
|
|
|
|
|
|
|
|
>> Utilize <Delete> para deletar o texto at<61> a linha caber em uma linha
|
|
|
|
|
novamente. A linha de continua<75><61>o ir<69> embora.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode deletar o caractere de nova linha como qualquer outro
|
|
|
|
|
caracter. Deletando o caractere de nova linha entre duas linhas voc<6F>
|
|
|
|
|
juntar<EFBFBD> as duas em uma <20>nica linha. Se o resultado for muito longo para
|
|
|
|
|
acomodar na largura da tela, aparecer<65> um caractere de continua<75><61>o.
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para o inicio da linha e digite <Delete>. Isso juntar<61>
|
|
|
|
|
esta linha com a anterior.
|
|
|
|
|
|
|
|
|
|
>> Digite <Return> para re-inserir a nova linha que voc<6F> deletou.
|
|
|
|
|
|
|
|
|
|
Lembre-se que a maioria dos comandos do Emacs podem receber um n<>mero de
|
|
|
|
|
repeti<EFBFBD><EFBFBD>o; isso inclui texto de caracteres. Repetir um texto de
|
|
|
|
|
caractere o insere algumas vezes.
|
|
|
|
|
|
|
|
|
|
>> Tente isso agora -- digite C-u 8 * para inserir ********.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> acabou de aprender o jeito mais simples de digitar alguma coisa no
|
|
|
|
|
Emacs e corrigir os erros. Voc<6F> pode deletar palavras ou linhas
|
|
|
|
|
tamb<EFBFBD>m. Aqui vai um sum<75>rio dos comandos de dele<6C><65>o:
|
|
|
|
|
|
|
|
|
|
<Delete> deleta o caractere imediatamente antes do cursor
|
|
|
|
|
M-d deleta o pr<70>ximo caractere apos o cursor
|
|
|
|
|
|
|
|
|
|
M-<Delete> Mata a palavra imediatamente antes do cursor
|
|
|
|
|
M-d Mata a pr<70>xima palavra depois do cursor
|
|
|
|
|
|
|
|
|
|
C-k Mata a posi<73><69>o do cursor at<61> o fim da linha
|
|
|
|
|
M-k Mata at<61> o fim da senten<65>a corrente
|
|
|
|
|
|
|
|
|
|
Note que o <Delete> e o C-d vs M-<Delete> e M-d estende o paralelo
|
|
|
|
|
iniciado por C-f e M-f (bem, <Delete> n<>o <20> realmente um controle de
|
|
|
|
|
caractere, mas n<>o vamos nos preocupar com isso). C-k e M-k s<>o como C-e
|
|
|
|
|
e M-e, uma parte, nessas linhas s<>o senten<65>as opostas.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode tamb<6D>m matar parte de um buffer com um m<>todo uniforme. Mova
|
|
|
|
|
para o fim dessa parte, e digite C-@ ou C-SPC (um ou outro). (SPC <20> a
|
|
|
|
|
Barra de Espa<70>o.) Mova para o outro fim dessa parte, e digite C-w. Isso
|
|
|
|
|
ira matar todo o texto entre as duas posi<73><69>es.
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para o V no inicio do par<61>grafo anterior.
|
|
|
|
|
>> Digite C-SPC. Emacs vai mostrar a mensagem "Mark set" no rodap<61> da
|
|
|
|
|
tela.
|
|
|
|
|
>> Mova o cursor para o . (ponto) no "fim", na segunda linha do
|
|
|
|
|
par<61>grafo.
|
|
|
|
|
>> Digite C-w. Isso vai matar o texto iniciando no V, e terminando bem
|
|
|
|
|
antes do . (ponto).
|
|
|
|
|
|
|
|
|
|
A diferen<65>a entra "matar" e "deletar" <20> que o texto "matado" pode ser
|
2004-05-16 06:33:53 +00:00
|
|
|
|
re-inserido, onde os textos "deletados" n<>o podem ser re-inseridos.
|
2004-05-14 07:12:29 +00:00
|
|
|
|
Re-inser<65><72>o de um texto matado chama-se colar (yanking). Geralmente, o
|
|
|
|
|
comando que pode remover bastante texto mata o texto (eles fazem com que
|
|
|
|
|
voc<EFBFBD> possa colar (yank) o texto), enquanto os comandos que removem um
|
|
|
|
|
caractere, ou apenas linhas brancas ou espa<70>os, fazem dele<6C><65>o (para que
|
|
|
|
|
voc<EFBFBD> n<>o possa colar esse texto).
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para o inicio da linha que n<>o esteja vazia.
|
|
|
|
|
Agora digite C-k para matar o texto nessa linha.
|
|
|
|
|
>> Digite C-k pela segunda vez. Voc<6F> ver<65> que a nova linha que segue a
|
|
|
|
|
linha ser<65> matada.
|
|
|
|
|
|
|
|
|
|
Note que um simples C-k mata o conte<74>do de uma linha, <20> um segundo C-k
|
|
|
|
|
mata a linha, e faz com que todas as outras linhas movam para cima. C-k
|
|
|
|
|
trata um argumento num<75>rico especialmente: ele mata tantas linhas E seus
|
|
|
|
|
conte<EFBFBD>dos. Isso n<>o <20> uma simples repeti<74><69>o. C-u 2 C-k mata duas linhas
|
|
|
|
|
e suas novas linhas; digitar C-k duas vezes n<>o faria isso.
|
|
|
|
|
|
|
|
|
|
Para trazer o texto matado novamente <20> chamado colar "yaking". (Pense
|
|
|
|
|
nisso como colar, ou trazer de volta, algum texto que foi levado
|
|
|
|
|
embora.) Voc<6F> pode colar (yank) o texto matado no mesmo lugar onde ele
|
|
|
|
|
foi matado, ou em qualquer outro lugar do buffer, ou ate em um arquivo
|
|
|
|
|
diferente. Voc<6F> pode colar o texto diversas vezes, o que far<61> diversas
|
|
|
|
|
copias dele.
|
|
|
|
|
|
|
|
|
|
O comando para colar <20> C-y. Ele re-insere o ultimo texto matado, na
|
|
|
|
|
posi<EFBFBD><EFBFBD>o corrente do cursor.
|
|
|
|
|
|
|
|
|
|
>> Tente; digite C-y para colar o texto novamente.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> fizer diversos C-k's em uma linha, todo esse texto matado ser<65>
|
|
|
|
|
salvo junto, ent<6E>o aquele C-y vai colar todas aquelas linhas de uma vez.
|
|
|
|
|
|
|
|
|
|
>> Faca isso agora, digite C-k diversas vezes.
|
|
|
|
|
|
|
|
|
|
Agora pegue o texto matado:
|
|
|
|
|
|
|
|
|
|
Digite C-y. Ent<6E>o mova o cursor para baixo algumas linhas e digite C-y
|
|
|
|
|
novamente. Agora voc<6F> sabe como copiar determinado texto.
|
|
|
|
|
|
|
|
|
|
O que voc<6F> faria se voc<6F> tivesse determinado texto que voc<6F> gostaria de
|
|
|
|
|
colar, e ent<6E>o voc<6F> mata alguma outra coisa? C-y ira colar o kill mais
|
|
|
|
|
recente. Mas o antigo texto ainda n<>o foi perdido. Voc<6F> pode t<>-lo
|
|
|
|
|
novamente usando o comando M-y. Depois que voc<6F> der um C-y para pegar o
|
|
|
|
|
kill mais recente, digitar M-y troca o que voc<6F> colou pelo anterior a
|
|
|
|
|
ele. Digitar M-y novamente e novamente traz kills anteriores e
|
|
|
|
|
anteriores. Quando voc<6F> tiver alcan<61>ado o texto que voc<6F> que esta
|
|
|
|
|
procurando, voc<6F> n<>o precisa fazer nada para mant<6E>-lo. Apenas continue
|
|
|
|
|
com a sua edi<64><69>o, deixando o texto onde ele esta.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> digitar M-y o suficiente, voc<6F> come<6D>ar<61> do inicio novamente (o
|
|
|
|
|
kill mais recente).
|
|
|
|
|
|
|
|
|
|
>> Mate uma linha, mova por ai, mate mais uma linha.
|
|
|
|
|
Agora digite C-y para colar a segunda linha matada.
|
|
|
|
|
Agora digite M-y e ele vai ser trocado pelo primeiro kill.
|
|
|
|
|
Faca mais alguns M-y's e veja o que voc<6F> tem. Faca isso ate que o
|
|
|
|
|
segundo kill volte, e depois mais alguns.
|
|
|
|
|
Se voc<6F> preferir, voc<6F> pode tentar dar argumentos positivos e
|
|
|
|
|
negativos.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* DESFAZENDO (UNDO)
|
|
|
|
|
-------------------
|
|
|
|
|
|
|
|
|
|
Se voc<6F> fizer uma mudan<61>a no texto, e ent<6E>o decidir que isso foi um
|
|
|
|
|
erro, voc<6F> pode desfazer com o comando de desfazer (undo), C-x u.
|
|
|
|
|
|
|
|
|
|
Normalmente, C-x u desfaz as mudan<61>as feitas por um comando; se voc<6F>
|
|
|
|
|
repetir C-x u diversas vezes em uma linha, cada repeti<74><69>o ir<69> desfazer
|
|
|
|
|
um comando adicional.
|
|
|
|
|
|
|
|
|
|
Mas tem duas exce<63><65>es: comandos que n<>o trocam o texto n<>o contam (isso
|
|
|
|
|
inclui o movimento do cursor e a barra de rolagem), e caracteres
|
|
|
|
|
auto-inseridos s<>o usualmente cuidados em grupos de mais de 20 (Isso e
|
|
|
|
|
para reduzir o numero de C-x u's que voc<6F> deve digitar para desfazer a
|
|
|
|
|
inser<EFBFBD><EFBFBD>o de um texto.).
|
|
|
|
|
|
|
|
|
|
>> Mate essa linha com C-k, ent<6E>o digite C-x u e isso vai re-aparecer.
|
|
|
|
|
|
|
|
|
|
C-_ <20> um comando alternativo para desfazer; ele funciona exatamente como
|
|
|
|
|
o C-x u, mas <20> mais f<>cil de digitar diversas vezes em uma linha. A
|
|
|
|
|
desvantagem de C-_ <20> que alguns teclados ele n<>o <20> t<>o obvio para
|
|
|
|
|
digitar. <20> exatamente por isso que o C-x u <20> fornecido. Em alguns
|
|
|
|
|
terminais, voc<6F> pode digitar C-_ digitando / enquanto segurando o
|
|
|
|
|
CONTROL.
|
|
|
|
|
|
|
|
|
|
Um argumento num<75>rico para C-_ ou C-x u age como um contador de
|
|
|
|
|
repeti<EFBFBD><EFBFBD>o.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode desfazer a dele<6C><65>o de texto da mesma maneira que voc<6F> pode
|
|
|
|
|
desfazer o kill de um texto. A distin<69><6E>o entre matar e deletar alguma
|
|
|
|
|
coisa afeta se voc<6F> pode colar com C-y; isso n<>o faz diferen<65>a pro
|
|
|
|
|
desfazer (undo).
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* ARQUIVOS
|
|
|
|
|
----------
|
|
|
|
|
|
|
|
|
|
Para poder fazer o texto que voc<6F> edita permanente, voc<6F> precisa
|
|
|
|
|
coloca-lo em um arquivo. Ou ent<6E>o, isso ser<65> perdido quando o seu Emacs
|
|
|
|
|
for fechado. Para colocar seu texto em um arquivo, voc<6F> precisa
|
|
|
|
|
"encontrar" o arquivo antes de digitar o texto (Isso tamb<6D>m <20> chamado
|
|
|
|
|
"visitar" um arquivo.).
|
|
|
|
|
|
|
|
|
|
Encontrando um arquivo significa que voc<6F> ver<65> o conte<74>do de um arquivo
|
|
|
|
|
com o Emacs. De diversas maneiras, isso <20> como se voc<6F> estivesse
|
|
|
|
|
editando o arquivo. De qualquer maneira, as mudan<61>as que voc<6F> fizer
|
|
|
|
|
utilizando o Emacs n<>o se tornar<61>o permanente ate que voc<6F> "salve" o
|
|
|
|
|
arquivo. Isso e para que voc<6F> evite deixar um arquivo meio-modificado no
|
|
|
|
|
sistema enquanto voc<6F> n<>o quer isso. Mesmo quando voc<6F> salva, o Emacs
|
|
|
|
|
deixa o arquivo original sobre um arquivo de nome alterado no caso que
|
|
|
|
|
voc<EFBFBD> mais tarde decida que aquelas mudan<61>as foram um erro.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> olhar no rodap<61> da tela voc<6F> ver<65> a linha que come<6D>a e termina
|
|
|
|
|
com tra<72>os e inicia com "--:-- TUTORIAL.pt_BR" ou algo parecido com
|
|
|
|
|
isso. Essa parte da tela normalmente mostra o nome do arquivo que voc<6F>
|
|
|
|
|
esta visitando. Agora mesmo, voc<6F> esta visitando um arquivo chamado
|
|
|
|
|
"TUTORIAL.pt_BR" que <20> sua pr<70>pria copia do tutorial do Emacs. Quando
|
|
|
|
|
voc<EFBFBD> encontra um arquivo com o Emacs, o nome do arquivo aparecera nesse
|
|
|
|
|
lugar especifico.
|
|
|
|
|
|
|
|
|
|
Algo especial para se dizer sobre o comando de encontrar arquivo e que
|
|
|
|
|
voc<EFBFBD> tem que dizer qual nome do arquivo voc<6F> quer. Dizemos que o comando
|
|
|
|
|
"l<> um argumento do terminal" (nesse caso, o argumento e o nome do
|
|
|
|
|
arquivo). Depois que voc<6F> digitar o comando
|
|
|
|
|
|
|
|
|
|
C-x C-f Encontrar um arquivo
|
|
|
|
|
|
|
|
|
|
O Emacs pede para voc<6F> digitar o nome do arquivo. O nome do arquivo
|
|
|
|
|
aparece no rodap<61> da tela. A linha de rodap<61> <20> chamada de minibuffer
|
|
|
|
|
quando <20> utilizada para esse tipo de introdu<64><75>o de dados. Voc<6F> pode
|
|
|
|
|
utilizar os comandos padr<64>es do Emacs para editar o nome do arquivo.
|
|
|
|
|
|
|
|
|
|
Enquanto voc<6F> estiver digitando o nome do arquivo (ou qualquer outro
|
|
|
|
|
tipo de dado para o minibuffer), voc<6F> pode cancelar o comando com a
|
|
|
|
|
tecla C-g.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x C-f, ent<6E>o digite C-g. Isso cancelara o minibuffer, e
|
|
|
|
|
tamb<6D>m cancelara o comando C-x C-f que estava sendo utilizado no
|
|
|
|
|
minibuffer. Para que voc<6F> n<>o procure nenhum arquivo.
|
|
|
|
|
|
|
|
|
|
Quando voc<6F> terminar de digitar o nome do arquivo, digite <Return> para
|
|
|
|
|
terminar. Ent<6E>o o comando C-x C-f ira trabalhar, e encontrar o arquivo
|
|
|
|
|
que voc<6F> escolheu. O minibuffer desaparece quando o comando C-x C-f e
|
|
|
|
|
finalizado.
|
|
|
|
|
|
|
|
|
|
Em pouco tempo o conte<74>do do arquivo aparece na tela, e voc<6F> poder<65>
|
|
|
|
|
editar o conte<74>do dele. Quando voc<6F> terminar de fazer suas altera<72><61>es
|
|
|
|
|
permanentes digite o comando
|
2004-05-16 06:33:53 +00:00
|
|
|
|
|
2004-05-14 07:12:29 +00:00
|
|
|
|
C-x C-s Salve o arquivo
|
|
|
|
|
|
|
|
|
|
Isso copia o texto do Emacs para o arquivo. A primeira vez que voc<6F>
|
|
|
|
|
fizer isso, o Emacs vai renomear o arquivo original para um novo nome
|
|
|
|
|
para que voc<6F> n<>o o perca. O nome novo e feito adicionando "~" no fim do
|
|
|
|
|
nome original do arquivo.
|
|
|
|
|
|
|
|
|
|
Quando o salvamento for conclu<6C>do, Emacs imprimira o nome do arquivo
|
|
|
|
|
escrito. Voc<6F> deve salvar o conte<74>do do seu arquivo regularmente, para
|
|
|
|
|
que voc<6F> n<>o perca muito trabalho caso o sistema caia por um algum
|
|
|
|
|
motivo.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x C-s, salvara a copia do seu tutorial.
|
|
|
|
|
Isso ira imprimir "Wrote ...TUTORIAL.pt_BR" no fim da tela.
|
|
|
|
|
|
|
|
|
|
NOTA: Em alguns sistemas, digitar C-x C-s ira travar a tela e voc<6F> n<>o
|
|
|
|
|
ver<EFBFBD> sa<73>da do Emacs. Isso indica que um "recurso" do sistema operacional
|
|
|
|
|
chamado "controle de fluxo" (flow control) esta interceptando o C-s e
|
|
|
|
|
n<EFBFBD>o deixando que passe pelo Emacs. Para destravar a tela, digite
|
|
|
|
|
C-q. Ent<6E>o, leia na se<73><65>o "Spontaneous Entry to Incremental Search" no
|
|
|
|
|
manual do Emacs para uma dica de como lhe dar com esse "recurso".
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode encontrar um arquivo j<> existente, para ver ou edita-lo. Voc<6F>
|
|
|
|
|
tamb<EFBFBD>m pode encontrar um arquivo que ainda n<>o existe. Essa <20> a maneira
|
|
|
|
|
de criar um arquivo com o Emacs: encontre o arquivo, que ira iniciar
|
|
|
|
|
vazio, ent<6E>o inicie inserindo o texto para o arquivo. Quando voc<6F> pedir
|
|
|
|
|
para "salvar" o arquivo, Emacs ir<69> perguntar se voc<6F> realmente quer
|
|
|
|
|
criar o arquivo com o texto que voc<6F> acabou de inserir. De agora em
|
|
|
|
|
diante, voc<6F> pode considerar que esta editando um arquivo j<> existente.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* BUFFERS
|
|
|
|
|
---------
|
|
|
|
|
|
|
|
|
|
Se voc<6F> encontrar um segundo arquivo com C-x C-f, o primeiro continuara
|
|
|
|
|
dentro do Emacs. Voc<6F> pode voltar para ele encontrando-o novamente com
|
|
|
|
|
C-x C-f. Dessa maneira voc<6F> pode ter um grande numero de arquivos dentro
|
|
|
|
|
do Emacs.
|
|
|
|
|
|
|
|
|
|
>> Crie um arquivo chamado "foo" digitando C-x C-f foo <Return>.
|
|
|
|
|
Depois digite algum texto, edite-o, e salve "foo" digitando C-x C-s.
|
|
|
|
|
Finalmente, digite C-x C-f TUTORIAL.pt_BR <Return> para voltar ao
|
|
|
|
|
tutorial.
|
|
|
|
|
|
|
|
|
|
O Emacs guarda cada texto de um arquivo em um objeto chamado
|
|
|
|
|
"buffer". Encontrar um arquivo cria um novo buffer dentro do Emacs. Para
|
|
|
|
|
ver uma lista dos buffers que existem no servi<76>o do seu Emacs, digite
|
|
|
|
|
|
|
|
|
|
C-x C-b Lista os buffers
|
|
|
|
|
|
|
|
|
|
>> Tente C-x C-b agora.
|
|
|
|
|
|
|
|
|
|
Veja como cada buffer tem um nome, e ele tamb<6D>m pode ter um nome de
|
|
|
|
|
arquivo para o conte<74>do de arquivo que ele armazena. Alguns buffers n<>o
|
|
|
|
|
correspondem a arquivos. Por exemplo, o buffer chamado "*Buffer List*"
|
|
|
|
|
n<EFBFBD>o tem nenhum arquivo. Esse <20> o buffer que contem a lista de buffers
|
|
|
|
|
que foi feito com C-x C-b. QUALQUER texto que voc<6F> ver numa janela do
|
|
|
|
|
Emacs e sempre parte de algum buffer.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x 1 para sair da lista dos buffers.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> fizer mudan<61>as no texto de um arquivo, ent<6E>o encontrar um novo
|
|
|
|
|
arquivo, isso n<>o salva o conte<74>do do primeiro arquivo. As mudan<61>as
|
|
|
|
|
continuam dentro do Emacs, nos buffers de arquivo. A cria<69><61>o ou edi<64><69>o
|
|
|
|
|
do buffer do segundo arquivo n<>o tem nenhum efeito no buffer do primeiro
|
|
|
|
|
arquivo. Isso <20> muito <20>til, mas tamb<6D>m significa que voc<6F> precisa de uma
|
|
|
|
|
maneira conveniente de salvar o buffer do primeiro arquivo. Seria
|
|
|
|
|
inconveniente ter que voltar para ele com C-x C-f para salva-lo com C-x
|
|
|
|
|
C-s. Por isso temos
|
|
|
|
|
|
|
|
|
|
C-x s Salve alguns buffers
|
|
|
|
|
|
|
|
|
|
C-x s pergunta a voc<6F> sobre cada buffer que contem modifica<63><61>o e voc<6F>
|
|
|
|
|
n<EFBFBD>o salvou. Ele te pergunta, para cada buffer, se voc<6F> quer salvar.
|
|
|
|
|
|
|
|
|
|
>> Insira uma linha de texto, ent<6E>o digite C-x s.
|
|
|
|
|
Isso deve te perguntar se voc<6F> quer salvar o buffer chamado
|
|
|
|
|
TUTORIAL.pt_BR.
|
|
|
|
|
Responda sim para a pergunta digitando "y".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* ESTENDENDO O COMANDO SET
|
|
|
|
|
--------------------------
|
|
|
|
|
|
|
|
|
|
Existem mais, muito mais comandos que o Emacs poderia possivelmente ser
|
|
|
|
|
colocado em todos os control e caracteres meta. O Emacs faz isso com o
|
|
|
|
|
comando X (estender). Que vem em duas vers<72>es:
|
|
|
|
|
|
|
|
|
|
C-x Extensor de caractere. Seguido por um caractere.
|
|
|
|
|
M-x Extensor de nome de comando. Seguido por um longo nome.
|
|
|
|
|
|
|
|
|
|
Esses comandos que s<>o geralmente <20>teis mas pouco usados que os comandos
|
|
|
|
|
que voc<6F> j<> aprendeu. Voc<6F> j<> viu dois deles: os comandos de arquivos
|
|
|
|
|
C-x C-f para Encontrar e C-x C-s para Salvar. Outro exemplo de um
|
|
|
|
|
comando para finalizar a sess<73>o do Emacs - esse <20> o comando C-x C-c (N<>o
|
|
|
|
|
se preocupe em perder as mudan<61>as que voc<6F> fez; C-x C-c oferece salvar
|
|
|
|
|
cada arquivo modificado antes de matar o Emacs.).
|
|
|
|
|
|
|
|
|
|
C-z <20> o comando para sair do Emacs *temporariamente* - ent<6E>o voc<6F> pode
|
|
|
|
|
voltar para a mesma se<73><65>o do Emacs depois.
|
|
|
|
|
|
|
|
|
|
Em sistemas que permitem isso, C-z "suspende" o Emacs; isso e, retorna
|
|
|
|
|
ao shell mas n<>o destr<74>i o Emacs. Nos shells mais comum, voc<6F> pode
|
|
|
|
|
resumir o Emacs com o comando 'fg' ou com '%emacs'.
|
|
|
|
|
|
|
|
|
|
Nos sistemas que n<>o implementam suspens<6E>o, C-z cria um subshell rodando
|
|
|
|
|
sobre o Emacs para dar a voc<6F> a chance de rodar outros programas e
|
|
|
|
|
retornar ao Emacs depois; isso n<>o "sai" verdadeiramente do Emacs. Nesse
|
|
|
|
|
caso, o comando shell 'exit' <20> o comando usual para voltar ao Emacs do
|
|
|
|
|
subshell.
|
|
|
|
|
|
|
|
|
|
A hora de usar o C-x C-c <20> quando voc<6F> esta prestes a sair do sistema
|
|
|
|
|
operacional. <20> tamb<6D>m a maneira correta de sair do Emacs quando chamado
|
|
|
|
|
atrav<EFBFBD>s de um cliente de e-mail ou outros utilit<69>rios, porque eles n<>o
|
|
|
|
|
controlam a suspens<6E>o do Emacs. Em outras circunst<73>ncias, se voc<6F> n<>o
|
|
|
|
|
estiver saindo do sistema operacional, <20> melhor suspender o Emacs com
|
|
|
|
|
C-z ao inv<6E>s de sair do Emacs.
|
|
|
|
|
|
|
|
|
|
Existem diversos comando C-x. Aqui esta uma lista dos que voc<6F> aprendeu:
|
|
|
|
|
|
|
|
|
|
C-x C-f Encontrar arquivo.
|
|
|
|
|
C-x C-s Salvar arquivo.
|
|
|
|
|
C-x C-b Listar buffers.
|
|
|
|
|
C-x C-c Sair do Emacs.
|
|
|
|
|
C-x 1 Deletar todas menos a janela atual.
|
|
|
|
|
C-x u Desfazer.
|
|
|
|
|
|
|
|
|
|
O extensor de nome de comando <20> usado menos ainda, ou comandos que s<>o
|
|
|
|
|
usados apenas em alguns modos. Um exemplo <20> o comando replace-string,
|
|
|
|
|
que globalmente troca uma string por outra. Quando voc<6F> digita M-x, o
|
|
|
|
|
Emacs te pergunta no rodap<61> da tela M-x e voc<6F> deve digitar o nome do
|
|
|
|
|
comando; nesse caso, "replace-string". Apenas digite "repl s<TAB>" e o
|
|
|
|
|
Emacs ira completar o nome. (<TAB> <20> a tecla Tab, usualmente encontrando
|
|
|
|
|
abaixo do CapsLock ou Shift bem na extremidade do teclado.). Termine o
|
2004-05-16 06:33:53 +00:00
|
|
|
|
comando com <Return>.
|
2004-05-14 07:12:29 +00:00
|
|
|
|
|
|
|
|
|
O comando replace-string requer dois argumentos - a string para ser
|
|
|
|
|
trocada, e a string que ira substitui-la. Voc<6F> precisa terminar cada
|
|
|
|
|
argumento com <Return>.
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para a linha branca duas linhas abaixo dessa.
|
|
|
|
|
Digite ent<6E>o M-x repl s<Return>mudou<Return>alterado<Return>.
|
|
|
|
|
|
|
|
|
|
Note como essa linha mudou: voc<6F> substituiu a palavra m-u-d-o-u por
|
|
|
|
|
"alterado" quando ocorreu, apos a posi<73><69>o inicial do cursor.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* SALVAMENTO AUTOM<4F>TICO
|
|
|
|
|
-----------------------
|
|
|
|
|
|
|
|
|
|
Quando voc<6F> fizer mudan<61>as em um arquivo, mas voc<6F> ainda n<>o tiver
|
|
|
|
|
salvo, elas podem ser perdidas se o seu computador der pau. Para
|
|
|
|
|
proteger voc<6F> disso, o Emacs periodicamente escreve um arquivo "auto
|
|
|
|
|
salvo" para cada arquivo que voc<6F> estiver editando. O nome do arquivo
|
|
|
|
|
auto salvo tem um # no inicio e no fim; por exemplo, se o seu arquivo
|
|
|
|
|
tiver o nome "ola.c", o nome do arquivo auto salvo dele ser<65>
|
|
|
|
|
"#ola.c#". Quando voc<6F> salvar o arquivo da maneira normal, o Emacs
|
|
|
|
|
deleta os arquivos auto salvos.
|
|
|
|
|
|
|
|
|
|
Se o computador der pau, voc<6F> pode recuperar suas modifica<63><61>es auto
|
|
|
|
|
salvas abrindo o arquivo normalmente (o arquivo que voc<6F> estava
|
|
|
|
|
editando, n<>o o arquivo auto-salvo) e ent<6E>o digitar M-x recover
|
|
|
|
|
file<Return>. Quando isso perguntar por confirma<6D><61>o, digite yes<Return>
|
|
|
|
|
para ir em frente e recuperar os dados auto salvos.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* <20>REA DE SA<53>DA (ECHO AREA)
|
|
|
|
|
---------------------------
|
|
|
|
|
|
|
|
|
|
Se o Emacs ver que voc<6F> esta digitando comandos multi-caractere
|
|
|
|
|
lentamente, ele os mostrara para voc<6F> no fim da tela numa <20>rea chamada
|
|
|
|
|
<EFBFBD>rea de Sa<53>da ou Echo <20>rea. A <20>rea de sa<73>da contem a linha de rodap<61> da
|
|
|
|
|
tela.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* MODE LINE
|
|
|
|
|
-----------
|
|
|
|
|
|
|
|
|
|
A linha imediatamente acima da <20>rea de sa<73>da <20> chamada de "mode line". O
|
|
|
|
|
mode line diz algo algo mais ou menos assim:
|
|
|
|
|
|
|
|
|
|
--:** TUTORIAL.pt_BR (Fundamental)--L670--58%----------------
|
|
|
|
|
|
|
|
|
|
Essa linha da informa<6D><61>es <20>teis sobre o status do Emacs e o texto que
|
|
|
|
|
voc<EFBFBD> esta editando.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> j<> sabe o que o nome do arquivo significa -- <20> o arquivo que voc<6F>
|
|
|
|
|
encontrou. -NN%-- indica sua posi<73><69>o no arquivo texto; significa que NN
|
|
|
|
|
percento do texto esta acima do topo da tela. Se o topo do arquivo
|
|
|
|
|
estiver na tela, ele dir<69> --Top-- ao inv<6E>s de --00%--. Se o rodap<61> do
|
|
|
|
|
texto estiver na tela, ele mostrara --Bot--. Se voc<6F> estiver olhando um
|
|
|
|
|
texto muito pequeno que cabe na todo na tela, o mode line ira dizer
|
|
|
|
|
--All--.
|
|
|
|
|
|
|
|
|
|
O L s<>o d<>gitos e indicam a posi<73><69>o de uma outra maneira: eles mostram a
|
|
|
|
|
linha corrente do ponto.
|
|
|
|
|
|
|
|
|
|
Os asteriscos pr<70>ximo ao inicio significa que voc<6F> fez mudan<61>as ao
|
|
|
|
|
texto. Logo ap<61>s voc<6F> visitar um arquivo ou salvar um arquivo, essa
|
|
|
|
|
parte do mode line n<>o mostrara asteriscos, apenas tra<72>os.
|
|
|
|
|
|
|
|
|
|
A parte do mode line dentro do par<61>nteses lhe diz quais modos voc<6F> esta
|
|
|
|
|
utilizando. O modo padr<64>o <20> o Fundamental que <20> o que voc<6F> esta
|
|
|
|
|
utilizando agora. <20> um exemplo de um "modo majorit<69>rio".
|
|
|
|
|
|
|
|
|
|
O Emacs tem diversos diferentes modos majorit<69>rios. Alguns deles s<>o
|
|
|
|
|
para edi<64><69>o de diferentes linguagens de programa<6D><61>o e/ou tipos de texto,
|
|
|
|
|
como modo Lisp, modo Texto, etc. Em qualquer momento um <20> apenas um modo
|
|
|
|
|
majorit<EFBFBD>rio e ativo, e seu nome pode ser encontrado no mode line
|
|
|
|
|
exatamente onde o "Fundamental" esta agora.
|
|
|
|
|
|
|
|
|
|
Cada modo majorit<69>rio faz com que alguns comandos operem de modo
|
|
|
|
|
diferente. Por exemplo, existem comandos para criar coment<6E>rios nos
|
|
|
|
|
programas, e desde que cada linguagem de programa<6D><61>o tem uma id<69>ia
|
|
|
|
|
diferente de como um coment<6E>rio deve ser, cada modo majorit<69>rio tem que
|
|
|
|
|
inserir seus coment<6E>rios individualmente. Cada modo majorit<69>rio <20> o nome
|
|
|
|
|
de um comando estendido, e <20> assim que voc<6F> pode mudar para determinado
|
|
|
|
|
modo. Por exemplo, M-x fundamental-mode <20> o comando para trocar para o
|
|
|
|
|
modo Fundamental.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> vai editar texto em Portugu<67>s, como neste arquivo, voc<6F> pode
|
|
|
|
|
utilizar o modo Texto.
|
|
|
|
|
|
|
|
|
|
>> Digite M-x text mode<Return>.
|
|
|
|
|
|
|
|
|
|
N<EFBFBD>o se preocupe, nenhum dos comandos do Emacs que voc<6F> aprendeu
|
|
|
|
|
mudar<EFBFBD>o. Mas voc<6F> pode observar que o M-f e o M-b tratam os ap<61>strofos
|
|
|
|
|
como parte das palavras. Anteriormente, no modo Fundamental, M-f e M-b
|
|
|
|
|
trataram os ap<61>strofos como separadores de palavras.
|
|
|
|
|
|
|
|
|
|
Modos majorit<69>rios fazem usualmente modifica<63><61>es como esta: a maioria
|
|
|
|
|
dos comandos fazem "a mesma coisa" em cada modo majorit<69>rio, mas eles
|
|
|
|
|
trabalham um pouquinho diferente.
|
|
|
|
|
|
|
|
|
|
Para ver a documenta<74><61>o do seu modo majorit<69>rio, digite C-h m.
|
|
|
|
|
|
|
|
|
|
>> Utilize C-u C-v uma ou mais para trazer essa linha pr<70>xima ao topo da
|
|
|
|
|
tela.
|
|
|
|
|
>> Digite C-h m, para ver como o modo texto difere do modo Fundamental.
|
|
|
|
|
>> Digite C-x 1 para remover a documenta<74><61>o da tela.
|
|
|
|
|
|
|
|
|
|
Modos majorit<69>rios s<>o chamados de majorit<69>rios porque tamb<6D>m existem
|
|
|
|
|
modos minorit<69>rios. Modos minorit<69>rios n<>o s<>o alternativos aos modos
|
|
|
|
|
majorit<EFBFBD>rios, apenas uma modifica<63><61>o minorit<69>ria deles. Cada modo
|
|
|
|
|
minorit<EFBFBD>rio pode ser ligado ou desligado por ele mesmo, independente de
|
|
|
|
|
todos os outros modos minorit<69>rios, <20> independente do modo
|
|
|
|
|
majorit<EFBFBD>rio. Ent<6E>o voc<6F> pode n<>o utilizar modos minorit<69>rios, ou um modo
|
|
|
|
|
minorit<EFBFBD>rio, ou qualquer combina<6E><61>o de modos minorit<69>rios.
|
|
|
|
|
|
|
|
|
|
Um modo minorit<69>rio que <20> bastante <20>til, especialmente para editar texto
|
|
|
|
|
em Portugu<67>s, <20> o modo Auto Fill. Quando ele esta ligado, o Emacs quebra
|
|
|
|
|
a linha entre as palavras automaticamente quando voc<6F> inserir um texto e
|
|
|
|
|
criar uma linha muito comprida.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode ligar o modo Auto Fill fazendo M-x auto fill
|
|
|
|
|
mode<Return>. Quando o modo estiver ligado, voc<6F> pode desliga-lo
|
|
|
|
|
novamente fazendo M-x auto fill mode<Return>. Se o modo estiver
|
|
|
|
|
desligado, esse comando o liga, e se ele estiver ligado, este comando o
|
|
|
|
|
desligara. Nos dizemos que o comando inverte seu status.
|
|
|
|
|
|
|
|
|
|
>> Digite M-x auto fill mode<Return> agora. Ent<6E>o insira uma linha de
|
|
|
|
|
"asdf " diversas vezes ate que voc<6F> veja dividir em duas linhas. Voc<6F>
|
|
|
|
|
precisa colocar espa<70>os entre as palavras porque o modo Auto Fill
|
|
|
|
|
quebra apenas nos espa<70>os.
|
|
|
|
|
|
|
|
|
|
A margem <20> usualmente definida com 70 caracteres, mas voc<6F> pode
|
|
|
|
|
modifica-la com o comando C-x f. Voc<6F> deve dar a margem que voc<6F> quer
|
|
|
|
|
como um argumento num<75>rico.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x f com um argumento de 20. (C-u 20 C-x f).
|
|
|
|
|
Ent<6E>o digite algum texto e veja o Emacs encher linhas com ate 20
|
|
|
|
|
caracteres. Ent<6E>o, volte a definir a margem para 70 utilizando C-x f.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> fizer uma mudan<61>a no meio de um par<61>grafo, o modo Auto Fill n<>o
|
|
|
|
|
ira re-preencher para voc<6F>. Para re-preencher o par<61>grafo, digite M-q
|
|
|
|
|
(Meta-q) com o cursor dentro do par<61>grafo.
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor dentro do par<61>grafo anterior e digite M-q.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* PESQUISANDO
|
|
|
|
|
-------------
|
|
|
|
|
|
|
|
|
|
O Emacs pode fazer pesquisas por strings (esses sao grupos de caracteres
|
|
|
|
|
ligados ou palavras) tanto para frente do texto ou para traz. Pesquisar
|
|
|
|
|
por uma string e um comando de movimento do cursor; ele move o cursor
|
|
|
|
|
para o pr<70>ximo lugar onde a string aparece.
|
|
|
|
|
|
|
|
|
|
O comando de pesquisa do Emacs <20> diferente dos comandos de pesquisa da
|
|
|
|
|
maioria dos editores, porque <20> uma pesquisa "incremental". Isso
|
|
|
|
|
significa que a pesquisa acontece enquanto voc<6F> digita uma string para
|
|
|
|
|
pesquisar.
|
|
|
|
|
|
|
|
|
|
O comando para iniciar a pesquisa <20> C-s para pesquisa para frente ou C-r
|
|
|
|
|
para pesquisa inversa. MAS ESPERE! N<>o tente fazer agora.
|
|
|
|
|
|
|
|
|
|
Quando voc<6F> digitar C-s voc<6F> percebera que uma string "I-search"
|
|
|
|
|
aparecera como prompt na <20>rea de sa<73>da. Isso diz para voc<6F> que o Emacs
|
|
|
|
|
esta no que chamamos de pesquisa incremental esperando que voc<6F> digite o
|
|
|
|
|
que voc<6F> quer procurar. <Return> termina a pesquisa.
|
|
|
|
|
|
|
|
|
|
>> Agora digite C-s para iniciar a pesquisa. DEVAGAR, uma letra por vez,
|
|
|
|
|
digite o caractere 'cursor', pausando cada vez que voc<6F> digitar um
|
|
|
|
|
caractere, perceba o que acontece com o cursor. Agora que voc<6F>
|
|
|
|
|
pesquisou por "cursor", uma vez.
|
|
|
|
|
>> Digite C-s novamente, para pesquisa a pr<70>xima ocorr<72>ncia de "cursor".
|
|
|
|
|
>> Agora digite <Delete> quatro vezes e veja como o cursor move.
|
|
|
|
|
>> Digite <Return> para terminar a pesquisa.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> viu o que aconteceu? O Emacs, em uma pesquisa incremental, tenta ir
|
|
|
|
|
para a ocorr<72>ncia que voc<6F> digitou ate o momento. Para ir para pr<70>xima
|
|
|
|
|
ocorr<EFBFBD>ncia de 'cursor' apenas digite C-s novamente. Se nenhuma
|
|
|
|
|
ocorr<EFBFBD>ncia existir, o Emacs bipa e te diz que a pesquisa atual
|
|
|
|
|
falhou. C-g tamb<6D>m termina a pesquisa.
|
|
|
|
|
|
|
|
|
|
NOTA: Em alguns sistemas, digitar C-s ira travar a tela e voc<6F> n<>o ver<65>
|
|
|
|
|
sa<EFBFBD>da do Emacs. Isso indica que um "recurso" do sistema operacional
|
|
|
|
|
chamado "controle de fluxo" (flow control) esta interceptando o C-s e
|
|
|
|
|
n<EFBFBD>o deixando que passe pelo Emacs. Para destravar a tela, digite
|
|
|
|
|
C-q. Ent<6E>o, leia na se<73><65>o "Spontaneous Entry to Incremental Search" no
|
|
|
|
|
manual do Emacs para uma dica de como lhe dar com esse "recurso".
|
|
|
|
|
|
|
|
|
|
Se voc<6F> estiver no meio de uma pesquisa incremental e digitar <Delete>,
|
|
|
|
|
voc<EFBFBD> percebera que o ultimo caractere da pesquisa ser<65> apagado e a
|
|
|
|
|
pesquisa voltara para o ultimo lugar da pesquisa. Por instancia, imagine
|
|
|
|
|
que voc<6F> tenha digitado "c", para pesquisar a primeira ocorr<72>ncia de
|
|
|
|
|
"c". Agora se voc<6F> digitar "u", o cursor ira mover para a primeira
|
|
|
|
|
ocorr<EFBFBD>ncia de "cu". Agora digite <Delete>. Isso ira apagar o "u" da
|
|
|
|
|
string de pesquisa, e o cursor movera de volta para a primeira
|
|
|
|
|
ocorr<EFBFBD>ncia de "c".
|
|
|
|
|
|
|
|
|
|
Se voc<6F> estiver no meio de uma pesquisa e digitar um caractere control
|
|
|
|
|
ou meta (com algumas exce<63><65>es--caracteres que s<>o especiais em uma
|
|
|
|
|
pesquisa, como C-s e C-r), a pesquisa <20> terminada.
|
|
|
|
|
|
|
|
|
|
O C-s inicia uma pesquisa que procura por qualquer ocorr<72>ncia da string
|
|
|
|
|
de pesquisa AP<41>S a posi<73><69>o corrente do cursor. Se voc<6F> quiser pesquisar
|
|
|
|
|
por alguma coisa anterior no texto, digite C-r ao inv<6E>s. Tudo que nos
|
|
|
|
|
dissemos sobre C-s tamb<6D>m implica para C-r, tirando a dire<72><65>o da
|
|
|
|
|
pesquisa que <20> reversa.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* M<>LTIPLAS JANELAS
|
|
|
|
|
-------------------
|
|
|
|
|
|
|
|
|
|
Um dos recursos mais interessantes do Emacs <20> que voc<6F> pode mostrar mais
|
|
|
|
|
de uma janela na tela ao mesmo tempo.
|
|
|
|
|
|
|
|
|
|
>> Mova o cursor para essa linha e digite C-u 0 C-l (isso <20> control-L,
|
|
|
|
|
n<>o control-1).
|
|
|
|
|
|
|
|
|
|
>> Agora digite C-x 2 que vai dividir a tela em duas janelas.
|
|
|
|
|
As duas janelas v<>o mostrar esse tutorial. O cursor fica na janela
|
|
|
|
|
do topo.
|
|
|
|
|
|
|
|
|
|
>> Digite C-M-v para rolar para o fim da janela.
|
|
|
|
|
(Se voc<6F> n<>o tiver uma tecla Meta de verdade, digite ESC C-v.).
|
|
|
|
|
|
|
|
|
|
>> Digite C-x o ("o" para "outra") para mover o cursor para o rodap<61>
|
|
|
|
|
da janela.
|
|
|
|
|
>> Use C-v e M-v no rodap<61> da janela para roda-la.
|
|
|
|
|
Continue lendo essas dire<72><65>es na janela do topo.
|
2004-05-16 06:33:53 +00:00
|
|
|
|
|
2004-05-14 07:12:29 +00:00
|
|
|
|
>> Digite C-x o novamente para mover o cursor de volta para a janela
|
|
|
|
|
do topo.
|
|
|
|
|
O cursor na janela do topo esta exatamente como estava antes.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> pode continuar usando C-x o para alternar entre as janelas. Cada
|
|
|
|
|
janela tem sua pr<70>pria posi<73><69>o de cursor, mas apenas uma janela mostra o
|
|
|
|
|
cursor. Todos os comandos mais comuns de edi<64><69>o aplicam para a janela
|
|
|
|
|
que o cursor esta. Chamamos isso de "janela selecionada".
|
|
|
|
|
|
|
|
|
|
O comando C-M-v <20> muito <20>til para quando voc<6F> estiver editando o texto
|
|
|
|
|
em uma janela e utilizando a outra janela para referencia. Voc<6F> pode
|
|
|
|
|
manter o cursor sempre na janela que voc<6F> estiver editando, e avan<61>ar
|
|
|
|
|
pela outra janela seq<65>encialmente utilizando C-M-v.
|
|
|
|
|
|
|
|
|
|
C-M-v <20> um exemplo de um caractere CONTROL-META. Se voc<6F> tiver uma tecla
|
|
|
|
|
META real, voc<6F> pode digitar C-M-v segurando ambos CONTROL e META
|
|
|
|
|
enquanto digitar v. N<>o importa se CONTROL ou META "vem primeiro,"
|
|
|
|
|
porque ambas as teclas agem modificando o caractere que voc<6F> digita.
|
|
|
|
|
|
|
|
|
|
Se voc<6F> n<>o tiver um tecla META real, voc<6F> pode utilizar ESC ao inv<6E>s, a
|
|
|
|
|
ordem n<>o importa: voc<6F> precisa digitar ESC seguido por Control-v,
|
|
|
|
|
porque Control-ESC v n<>o ira funcionar. Isso porque ESC <20> um caractere
|
|
|
|
|
com seu pr<70>prio direito, n<>o <20> uma tecla de modifica<63><61>o.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x 1 (na janela do topo) para fugir da janela do rodap<61>.
|
|
|
|
|
|
|
|
|
|
(Se voc<6F> tivesse digitado C-x 1 na janela do rodap<61>, voc<6F> fugiria da
|
|
|
|
|
janela do topo. Pense neste comando como "Mantenha apenas uma janela--a
|
|
|
|
|
janela que estou dentro.")
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> n<>o precisa mostrar o mesmo buffer nas duas janelas. Se voc<6F>
|
|
|
|
|
utilizar C-x C-f para encontrar um arquivo em outra janela, a outra
|
|
|
|
|
janela n<>o mudara. Voc<6F> pode encontrar um arquivo em cada janela
|
|
|
|
|
independentemente.
|
|
|
|
|
|
|
|
|
|
Aqui esta uma maneira de utilizar duas janelas para mostrar coisas
|
|
|
|
|
diferentes:
|
|
|
|
|
|
|
|
|
|
>> Digite C-x 4 C-f seguido pelo nome de um dos seus arquivos.
|
|
|
|
|
Termine com <Return>. Veja o arquivo especificado aparece na janela
|
|
|
|
|
do rodap<61>. O cursor ira para l<>, tamb<6D>m.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x o para voltar a janela do topo, e C-x1 para deletar a
|
|
|
|
|
janela de rodap<61>.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* N<>VEIS RECURSIVOS DE EDI<44><49>O
|
|
|
|
|
-----------------------------
|
|
|
|
|
|
|
|
|
|
Algumas vezes voc<6F> entrara no que chamamos de "n<>vel de edi<64><69>o
|
|
|
|
|
recursiva". Isso <20> indicado por colchetes no mode line, envolvendo os
|
|
|
|
|
par<EFBFBD>nteses em volta do nome do modo majorit<69>rio. Por exemplo, voc<6F> pode
|
|
|
|
|
ver [(Fundamental)] ao inv<6E>s de (Fundamental).
|
|
|
|
|
|
|
|
|
|
Para sair desses n<>veis recorr<72>veis de edi<64><69>o, digite ESC ESC ESC. Isso
|
|
|
|
|
e um comando de todos os prop<6F>sitos "saia". Voc<6F> pode tamb<6D>m utilizar
|
|
|
|
|
para eliminar janelas extras, e sair de um minibuffer.
|
|
|
|
|
|
|
|
|
|
>> Digite M-x para entrar no minibuffer; ent<6E>o digite ESC ESC ESC para
|
|
|
|
|
sair.
|
|
|
|
|
|
|
|
|
|
Voc<EFBFBD> n<>o pode utilizar C-g para sair de um n<>vel de edi<64><69>o
|
|
|
|
|
recursiva. Isso porque o C-g <20> utilizado para cancelar comandos e
|
|
|
|
|
argumentos COM o n<>vel de edi<64><69>o recursiva.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* CONSEGUINDO MAIS AJUDA
|
|
|
|
|
------------------------
|
|
|
|
|
|
|
|
|
|
Neste tutorial nos tentamos suprimir informa<6D><61>es suficientes para que
|
|
|
|
|
voc<EFBFBD> comece a utilizar o Emacs. Existe tanto dispon<6F>vel sobre Emacs que
|
|
|
|
|
seria imposs<73>vel explicar tudo aqui. De qualquer maneira, voc<6F> pode
|
|
|
|
|
querer aprender mais sobre Emacs mesmo porque ele tem muitos outros
|
|
|
|
|
recursos <20>teis. O Emacs proporciona comandos para leitura de
|
|
|
|
|
documenta<EFBFBD><EFBFBD>o sobre comandos do Emacs. Esses comandos de "ajuda" iniciam
|
|
|
|
|
com o caractere Control-h, que <20> chamado de "o caractere de ajuda".
|
|
|
|
|
|
|
|
|
|
Para utilizar os recursos de ajuda, digite o caractere C-h, e ent<6E>o um
|
|
|
|
|
caractere dizendo que tipo de ajuda voc<6F> quer. Se voc<6F> REALMENTE estiver
|
|
|
|
|
perdido, digite C-h ? e o Emacs ira te dizer que tipo de ajuda ele pode
|
|
|
|
|
te dar. Se voc<6F> digitar C-h e decidir que voc<6F> n<>o quer nenhuma ajuda,
|
|
|
|
|
apenas digite C-g para cancelar.
|
|
|
|
|
|
|
|
|
|
(Alguns sistemas mudam o significado do caractere C-h. Eles n<>o deveriam
|
|
|
|
|
fazer isso para todos os usu<73>rios, ent<6E>o voc<6F> tem muito a reclamar com o
|
|
|
|
|
administrador do sistema. Enquanto isso, se C-h n<>o mostrar a mensagem
|
|
|
|
|
sobre ajuda no rodap<61> da tela, tente digitar a tecla F1 ou M-x help
|
|
|
|
|
<Return> ao inv<6E>s.)
|
|
|
|
|
|
|
|
|
|
O recurso de ajuda mais b<>sico <20> o C-h c. Digite C-h, e o caractere c, <20>
|
|
|
|
|
um comando de caractere ou seq<65><71>ncia; ent<6E>o o Emacs mostrara uma breve
|
|
|
|
|
descri<EFBFBD><EFBFBD>o do comando.
|
|
|
|
|
|
|
|
|
|
>> Digite C-h c C-p
|
|
|
|
|
A mensagem deve ser algo assim
|
|
|
|
|
|
|
|
|
|
C-p roda o comando linha-anterior
|
|
|
|
|
|
|
|
|
|
Isso diz a voc<6F> "o nome da fun<75><6E>o". Nome de fun<75><6E>es s<>o utilizados
|
|
|
|
|
basicamente para personalizar o estender o Emacs. Mas desde que nomes de
|
|
|
|
|
fun<EFBFBD><EFBFBD>es s<>o utilizados para indicar que o que o comando faz, eles podem
|
|
|
|
|
servir tamb<6D>m como uma breve documenta<74><61>o--suficiente para lembrar voc<6F>
|
|
|
|
|
os comandos que voc<6F> j<> aprendeu.
|
|
|
|
|
|
|
|
|
|
Comandos multi-caractere como C-x C-s e (se voc<6F> n<>o tiver a tecla META
|
|
|
|
|
ou EDIT ou ALT) <ESC>v <20> tamb<6D>m permitido depois de C-h c.
|
|
|
|
|
|
|
|
|
|
Para ter mais informa<6D><61>o sobre um comando, utilize C-h k ao inv<6E>s de C-h
|
|
|
|
|
c.
|
|
|
|
|
|
|
|
|
|
>> Digite C-h k C-p.
|
|
|
|
|
|
|
|
|
|
Isso mostra a documenta<74><61>o da fun<75><6E>o, assim como seu nome, em uma janela
|
|
|
|
|
do Emacs. Quando voc<6F> terminar de ler a sa<73>da, digite C-x 1 para sair da
|
|
|
|
|
sa<EFBFBD>da do texto de ajuda. Voc<6F> n<>o precisa fazer isso imediatamente
|
|
|
|
|
apos. Voc<6F> pode fazer alguma edi<64><69>o enquanto utilizando como referencia
|
|
|
|
|
o texto de ajuda, e ent<6E>o digite C-x 1.
|
|
|
|
|
|
|
|
|
|
Aqui est<73>o algumas outras op<6F><70>es <20>teis do comando C-h:
|
|
|
|
|
|
|
|
|
|
C-h f Descreve a fun<75><6E>o. Digite o nome da fun<75><6E>o.
|
|
|
|
|
|
|
|
|
|
>> Tente digitar C-h f previous-line<Return>
|
|
|
|
|
Isso ira imprimir toda informa<6D><61>o que o Emacs tem sobre a fun<75><6E>o que
|
|
|
|
|
implementa o comando C-p.
|
|
|
|
|
|
|
|
|
|
C-h a Comando Apropos. Digite uma palavra chave e o Emacs ira
|
|
|
|
|
listar todos os comandos que o nome contem essa
|
|
|
|
|
palavra. Esses comandos podem ser chamados com
|
|
|
|
|
Meta-x. Para alguns comandos, o comando Apropos ira
|
|
|
|
|
tamb<6D>m listar um ou dois caracteres de seq<65><71>ncia que
|
|
|
|
|
roda o mesmo comando.
|
|
|
|
|
|
|
|
|
|
>> Digite C-h a file<Return>.
|
|
|
|
|
|
|
|
|
|
Isso mostra em uma outra janela a lista de todos os comandos M-x com
|
|
|
|
|
"arquivo" em seus nomes. Voc<6F> Vera comandos-caractere como C-x C-f
|
|
|
|
|
listados ao lado do comando correspondente assim como o find-file.
|
|
|
|
|
|
|
|
|
|
>> Digite C-M-v para rolar a janela de ajuda. Faca isso algumas vezes.
|
|
|
|
|
|
|
|
|
|
>> Digite C-x 1 para deletar a janela de ajuda.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* CONCLUS<55>O
|
|
|
|
|
-----------
|
|
|
|
|
|
|
|
|
|
Lembre, para sair permanentemente do Emacs utilize C-x C-c. Para sair
|
|
|
|
|
para um shell temporariamente, para que voc<6F> possa voltar ao Emacs mais
|
|
|
|
|
tarde, utilize C-z.
|
|
|
|
|
|
|
|
|
|
Esse tutorial foi feito para ser entend<6E>vel para todos os novos
|
|
|
|
|
usu<EFBFBD>rios, ent<6E>o se voc<6F> encontrou algo que parece n<>o estar claro, n<>o
|
|
|
|
|
sente e se culpe - reclame!
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* C<>PIA
|
|
|
|
|
-------
|
|
|
|
|
|
|
|
|
|
Esse tutorial descende de uma longa linha de tutoriais do Emacs
|
|
|
|
|
iniciando com um escrito por Stuart Cracraft para o Emacs original.
|
|
|
|
|
|
|
|
|
|
Essa vers<72>o do tutorial foi originalmente traduzida por Marcelo Toledo
|
|
|
|
|
<marcelo@marcelotoledo.org> e como o GNU Emacs, tem um copyright, e vem
|
|
|
|
|
com uma permiss<73>o de distribui<75><69>o de c<>pias nas seguintes condi<64><69>es:
|
|
|
|
|
|
|
|
|
|
Copyright (c) 1985, 1996 Free Software Foundation
|
|
|
|
|
|
|
|
|
|
Permiss<73>o <20> garantida a qualquer um para fazer ou distribuir copias
|
|
|
|
|
integrais deste documento como recebido, em qualquer meio, deixando
|
|
|
|
|
dispon<6F>vel e preservados o aviso de copyright e o aviso de permiss<73>o,
|
|
|
|
|
e o distribuidor garante que a permiss<73>o para distribui<75><69>es
|
|
|
|
|
posteriores permitam o mesmo que esta nota.
|
|
|
|
|
|
|
|
|
|
Permiss<73>o garantida para distribuir vers<72>es modificadas deste
|
|
|
|
|
documento, ou partes dele, sobre as condi<64><69>es acima, sempre que elas
|
|
|
|
|
tenham uma nota vis<69>vel de quem foi o ultimo a alterar-lo.
|
|
|
|
|
|
|
|
|
|
As condi<64><69>es para copiar o Emacs especificamente s<>o mais complexas, mas
|
|
|
|
|
no mesmo esp<73>rito. Por favor, leia o arquivo COPYING e d<> copias do GNU
|
|
|
|
|
Emacs para seus amigos. Ajude a erradicar o obstrucionismo de software
|
|
|
|
|
("propriet<65>rio") usando, escrevendo, e compartilhando software livre!
|
2004-05-14 07:38:55 +00:00
|
|
|
|
|
2004-05-16 06:33:53 +00:00
|
|
|
|
;;; Local Variables:
|
|
|
|
|
;;; coding: latin-1
|
|
|
|
|
;;; sentence-end-double-space: nil
|
|
|
|
|
;;; End:
|
|
|
|
|
|
2004-05-14 07:38:55 +00:00
|
|
|
|
;;; arch-tag: 8ea256d6-2c4a-49ee-ac08-0ea6ef25bf8d
|