:TITLE: Avaliação e Substituições 1: Agrupando argumentos com ""
;#
;# RCSID: $Header: /home/clif/CVS_ROOT/TclTutor/Tcl3.lsn,v 1.19 2000/04/24 16:17:52 clif Exp $
;# Copyright (c) 1995 Clif Flynt
;# 9300 Fleming Rd.
;# Dexter, MI  48130
;# clif@cflynt.com
;# Veja o arquivo "AVISO" com os termos da licença.
;#
;#*********************************************************
;# Portuguese translation: Lucio Agostinho Rocha
;# E-mail: outrosdiasvirao@yahoo.com.br
;# Last update: 21/12/2005
;#*********************************************************
:LESSON_TEXT_START_LEVEL 0:
Esta lição é a primeira das três que discutem a forma como Tcl manipula substituição 
durante a avaliação de comandos.
<P>
Em Tcl, a avaliação de um comando é feita em 2 fases. A primeira fase é um único passo 
de substituições. A segunda fase é a avaliação do comando resultante. Note que apenas 
<I>um</I> passo de substituição é feito.
<P>
Durante a fase de substituição, muitos tipos de substituições ocorrem.
<P>
Um comando delimitado por colchetes ([]) é substituído com o retorno da execução 
daquele comando (Isso será explicado com mais detalhes na lição na lição 
"Resultados de um Comando - Math 101").
<P>
Aspas duplas ("") e chaves ({}) irão, ambas, agrupar palavras em um único argumento 
durante a fase de substituição, todavia, seus comportamentos diferem. O comportamento 
das chaves é coberto na próxima lição; a discussão a seguir é relativa a aspas duplas.
<P>
Agrupar palavras com aspas duplas permite que substituições ocorram dentro da delimitação. 
O grupo substituído é então avaliado como um único argumento.
<P>
Em geral, a barra invertida (\) desativa a substituição para um único caracter 
imediatamente seguinte à ela.
<P>
As exceções para esta última regra são as strings de "Seqüencia de Barra Invertida", 
que são substituídas como se segue:
<P><UL COMPACT>
<B>String........Saída...................................................Valor hexadecimal</B>
<LI>   \a...............Alerta audível (Bell)............................\x07
<LI>   \b...............Backspace...........................................\x08
<LI>   \f................Form Feed (Limpeza de tela)...........\x0c
<LI>   \n..............Nova linha.............................................\x0a
<LI>   \r...............Retorno de linha..................................\x0d
<LI>   \t...............Tabulação.............................................\x09
<LI>   \v..............Tabulação Vertical...............................\x0b
<LI>   \ddd.........Valor octal.............................................d = 0-7
<LI>   \xhh.........Valor hexadecimal...............................h = 0-9,A-F,a-f
</UL>
<P>
A exceção final é a barra invertida no fim de uma linha
de texto. Isso faz com que o interpretador ignore o caracter de nova linha,
e trate o texto como uma única linha de texto. O interpretador
irá inserir um espaço em branco na localização do final da
barra invertida.
<P>
Se você não clicou no botão <B>Executar exemplo</B> ainda,
faça isso agora e examine o resultado do exemplo. Brinque um
pouco com o código do exemplo, e então vá para a próxima lição.
:TEXT_END:
:LESSON_TEXT_START_LEVEL 1:
Essa lição é a primeira das três que discutem a forma como
Tcl manipula a substituição durante a avaliação de comandos.
<P>
Em Tcl, a avaliação de um comando é feita em 2 fases. A primeira
fase é um único passo de substituições. A segunda fase é a avaliação
do comando resultante. Note que apenas <I>um</I> passo das
substituições é feita. Portanto, no comando:
<PRE><CODE>
puts $nomeVariavel
</CODE></PRE>
<I>$nomeVariavel</I> é substituído pelo seu conteúdo, e então o comando é executado.
<P>
Durante a fase de substituição, muitos tipos de substituições ocorrem.
<P>
Um comando dentro de colchetes ([]) é substituído
com o retorno da execução daquele comando (Isso será
explicado com mais detalhes na lição 
"Resultados de um comando - Math 101").
<P>
Palavras delimitadas por aspas duplas ou chaves são
agrupadas em um único argumento. Todavia, aspas duplas e
chaves causam diferentes comportamentos durante a fase de
substituição. Nessa lição, nós iremos concentrar no 
comportamento das aspas duplas durante a fase de
substituição.
<P>
Agrupando palavras com aspas duplas permite que substituições
ocorram dentro da delimitação. O grupo substituído é então
avaliado como um único argumento.
<P>
Portanto, no comando:
<PRE><CODE>
     puts "O valor atual do estoque é: $nomeVariavel"
</CODE></PRE>
o conteúdo do valor atual de nomeVariavel é atribuído
para $nomeVariavel, e então toda a string é exibida
no dispositivo de saída.
<P>
Em geral, a barra invertida (\) desativa a substituição para
o caracter imediatamente seguinte à ela. Qualquer caracter
imediatamente seguinte à barra invertida ficará sem
substituição.
<P>
Todavia, há strings de "Seqüência de Barra Invertida"
que são substituídas pelo valor específico durante a fase
de substituição. As seguintes strings de barra invertida
serão substituídas como abaixo:
<P><UL COMPACT>
<B>String........Saída...................................................Valor hexadecimal</B>
<LI>   \a...............Alerta audível (Bell)............................\x07
<LI>   \b...............Backspace...........................................\x08
<LI>   \f................Form Feed (Limpeza de tela)...........\x0c
<LI>   \n..............Nova linha.............................................\x0a
<LI>   \r...............Retorno de linha..................................\x0d
<LI>   \t...............Tabulação.............................................\x09
<LI>   \v..............Tabulação Vertical...............................\x0b
<LI>   \ddd.........Valor octal.............................................d = 0-7
<LI>   \xhh.........Valor hexadecimal...............................h = 0-9,A-F,a-f
</UL>
<P>
A exceção final é a barra invertida no final de uma
linha de texto. Isso faz com que o interpretador 
ignore o caracter de nova linha, e trate o texto como
uma única linha de texto. O interpretador irá inserir
um espaço em branco na localização da barra invertida.
<P>
Se você não clicou ainda no botão <B>Executar exemplo</B>,
faça isso agora, e examine os resultados do exemplo. 
Brinque um pouco com o código do exemplo, e então
vá para a próxima lição.
:TEXT_END:
:LESSON_TEXT_START_LEVEL 2:
Esta lição é a primeira das três que discutem a
forma como Tcl manipula a substituição durante a
avaliação de comandos.
<P>
Em Tcl, a avaliação de um comando é feita em duas fases:
a fase de substituição e a fase de avaliação de um comando.
<P>
A fase de substituição é onde muito do "trabalho" no
programa Tcl é feito. O interpretador Tcl observa em cada
palavra, da esquerda para a direita e, quando ele encontra
uma palavra que deveria ser substituída por outro valor, ele
faz aquela substituição. Durante a fase de avaliação do comando,
o compilador avalia o comando, e realiza qualquer ação que
o comando requisita. Devido às substituições, o comando que
é avaliado pode não se parecer com o comando que você digitou.
<P>
Note que apenas <I>um</I> passo das substituições é feito.
<P>  
O interpretador Tcl realiza essas substituições:
<P>
Substitui <I>$nomeVariavel</I> com o conteúdo de <I>nomeVariável</I>.
<P>
No código do exemplo, o conteúdo de Z é "Araguari". Quando 
<CODE>puts "$Z_ROTULO $Z" </CODE> é avaliado, <I>$Z_ROTULO</I> é substituído com a string
"A capital do Brasil é:", e o $Z é substituído com "Araguari" antes
que <CODE>puts</CODE> seja chamado para exibir a string na saída padrão.
<P><UL COMPACT>
<B>String........Saída...................................................Valor hexadecimal</B>
<LI>   \a...............Alerta audível (Bell)............................\x07
<LI>   \b...............Backspace...........................................\x08
<LI>   \f................Form Feed (Limpeza de tela)...........\x0c
<LI>   \n..............Nova linha.............................................\x0a
<LI>   \r...............Retorno de linha..................................\x0d
<LI>   \t...............Tabulação.............................................\x09
<LI>   \v..............Tabulação Vertical...............................\x0b
<LI>   \ddd.........Valor octal.............................................d = 0-7
<LI>   \xhh.........Valor hexadecimal...............................h = 0-9,A-F,a-f
</UL>
<P>
Palavras delimitadas por aspas duplas ou chaves são avaliadas
como um único argumento. Todavia, aspas duplas e chaves
causam diferentes comportamentos durante a fase de
substituição. Nesta lição, nós iremos concentrar no
comportamento de aspas duplas durante a fase de
substituição.
<P>
Agrupando palavras com aspas duplas permite
que substituições ocorram dentro da delimitação durante
a fase de substituição. O grupo substituído é então
avaliado como um único argumento. Portanto, no comando
<PRE><CODE>
     puts "O valor atual do estoque é $nomeVariavel"
</CODE></PRE>
<I>$nomeVariavel</I> é substituído pelo seu conteúdo atual, e
então toda a string é exibida no dispositivo de saída.
<P>
Exceto para strings de "Seqüência de Barra Invertida" e
a barra invertida no fim de uma linha, a barra invertida (\)
desativa a substituição para o caracter imediatamente
seguinte à ela. Qualquer caracter imediatamente seguinte
à barra invertida ficará sem substituição. Esta é a forma
de se imprimir um sinal de sifrão ($). Sem uma barra invertida,
o $ é interpretado como um manipulador de lugar de variável.
<P>
Se você não clicou no botão <B>Executar exemplo</B> ainda, 
faça isso agora, e examine os resultados do exemplo. Brinque um 
pouco com o código do exemplo, e então vá para a próxima lição.
:TEXT_END:
<P>
:CODE_START:
;# Mostra como uma \ afeta o $
set Z "Araguari"
set Z_ROTULO "A capital do Brasil é:"

puts "$Z_ROTULO $Z"
puts "$Z_ROTULO \$Z"

;# A próxima linha precisa de uma barra invertida para exibir o '$'
puts "\nUma garoupa está na nota de R$100,00."

set a 100,00
puts "\nO beija-flor não está na nota de R$a"    ;# Isso não é o que você quer
puts "Uma onça pintada não está na nota de R$$a"      ;# Isso está certo
puts "Uma arara não está na nota de R\$a"     ;# Isso não é o que você quer
puts "Uma garoupa está na nota de R\$$a"    ;# Mas, isso está certo

puts "\n................. exemplos de strings de seqüência de barra invertida"
puts "Tabulação\tTabulação\tTabulação"
puts "Essa string é exibida \nem duas linhas"
puts "Esta string aparece em\
uma única linha"
:TEXT_END:
<P>