por Brent B. Welch
Sobre el Author:
Brent Welch se divierte construyendo el website www.scriptics.com, incluyendo
una base de datos comentada con URLs sobre el lenguaje Tcl (el
Tcl Resource
Center
) y la infraestructura de ecommerce para el producto TclPro.
También ha realizado varias aplicaciones grandes en Tcl/Tk, incluyendo
el servidor TclHttpd, que ejecuta www.scriptics.com, el interface de usuario
de correo Exmh y el editor de HTML webtk. Es el autor de
Practical
Programming in Tcl and Tk
.
Welch recibió BS (
Bachellor in Sciences
en Ingeniería
Aeroespacial en la Universidad de Colorado en Boulder (1982) y un MS
(
master in Science
) en Informática por la Universidad de
California en Berkeley (1986), y es doctor en Informática por
la Universidad de California en Berkeley (1990). Anteriormente
Welch fue miembro del equipo de investigación del
Palo Alto
Research Center
de Xerox
trabajando en sistemas distribuidos,
y más tarde fue miembro de el equipo Tcl/Tk de los laboratorios
de Sun Microsystems. Es también miembro de ACM
y de la IEEE Computer Society.
Home Page: http://www.beedub.com/
Contenidos:
- Introducción a la Sintaxis del Tcl
- Un Pequeño Ejemplo
- Agrupando y Sustituyendo
- Otro Ejemplo
- Ejecución de Comandos
- Un último Ejemplo
- Lecturas Complementarias
|
La Sintaxis del Tcl
Resumen:
Este artículo explica algunos conceptos básicos y la sintaxis
del lenguaje Tcl.
Introducción a la Sintaxis del Tcl
Para ser un lenguaje de scripts, Tcl tiene una sintaxis bastante simple.
cmd arg arg arg
- Un comando Tcl esta formado por palabras separadas por espacios en blanco.
La primera palabra es el nombre del comando, y las restantes palabras son
argumentos para el comando.
$foo
- El signo del dólar ($) sustituye el valor de una variable. En este
ejemplo, el nombre de la variable es foo.
[clock seconds]
- Los corchetes ejecutan comandos anidados. Por ejemplo, si quieres pasar
el resultado de un comando como argumento para otro, debes usar esta sintaxis.
En este ejemplo, el comando anidado es clock seconds, el cual devuelve
la hora actual en segundos.
"lo que sea"
- Las comillas agrupan palabras que se pasan al comando como un único
argumento. Los corchetes y el signo del dólar son reconocidos e
interpretados adecuadamente aunque se encuentren dentro de las comillas.
{lo que sea}
- Las llaves también agrupan palabras en argumentos simples. En este
caso, sin embargo, los elementos que haya dentro de las llaves no son interpretados.
\
- La barra invertida (\) se usa para expresar caracteres especiales. Por
ejemplo, \n genera una nueva linea. La barra invertida también se
usa para "anular" el significado especial del signo del dólar, comillas,
corchetes, y parentesis (serán tomados como caracteres normales).
Un Pequeño Ejemplo
Aquí tenemos un comando Tcl que muestra la hora actual. Usa tres
comandos Tcl:
set
, clock
, y puts
. El comando
set
asigna un valor a la variable. El comando clock
interactúa con el reloj. El comando puts
muestra los
valores.
set seconds [clock seconds]
puts "Son las [clock format $seconds]"
Tener en cuenta que no usamos el signo $ cuando asignemos variables.
Sólo cuando queramos el valor almacenado en la variable usaremos $.
La variable seconds
no es absolutamente necesaria en el ejemplo. Podemos mostrar la hora actual
con un solo comando:
puts "Son las [clock format [clock seconds]]"
Agrupando y Sustituyendo
La sintaxis Tcl es usada para guiar al parser (analizador sintáctico)
del Tcl a traves de tres etapas o pasos: agrupamiento de argumentos, sustitución
de resultados, y ejecución de comandos.
- Agrupamiento de argumentos. Tcl necesita determinar como organizar
los argumentos de los comandos. En el caso mas simple, los espacios en
blanco separan argumentos. Como se indicó antes, las comillas y
las llaves se usan para agrupar varias palabras en un solo argumento. En
el ejemplo anterior, las comillas se usan para agrupar varios elementos
como un simple argumento para el comando
puts
.
- Sustitución de resultados. Después de que los argumentos
sean agrupados, Tcl realiza la sustitución de cadenas. Dicho simplemente,
reemplaza
$foo
con el valor de la variable foo
, y
los comandos entre parentesis por su "resultado". Esas sustitutiones es
crucial que sean hechas después de las agrupaciones . Esta secuencia
asegura que valores inusuales no compliquen la estructura del comando.
- Ejecución de comandos. Despues de las sustituciones, Tcl
usa el nombre del comando como clave en una tabla de ejecución. Llama
al procedimiento C asociado en la tabla, y el éste implementa el
comando. También podemos escribir procedimientos con comandos de Tcl.
Hay convenciones simples sobre el paso de argumentos y el manejo de
errores.
Otro Ejemplo
Aquí tenemos otro ejemplo:
set i 0
while {$i < 10} {
puts "$i squared = [expr $i*$i]"
incr i
}
Aquí, las llaves son usadas para agrupar argumentos sin hacer
ninguna sustitución. El parser del Tcl no sabe nada en especial
acerca del comando while
. Lo trata como a cualquier otro
comando. Es la implementación del comando while
quien
sabe que el primer argumento es una expresión, y el segundo argumento
consta de más comandos Tcl. Las llaves agrupan dos argumentos: la
expresión lógica que controla el bucle y los comandos que hay
en el cuerpo del bucle.
También vemos dos expresiones matemáticas: la
comparación lógica y la multiplicación. El comando
while evalúa automáticamente su primer argumento como una
expresión. En otros casos deberemos usar explícitamente el
comando expr
para realizar evaluaciones matemáticas.
Ejecución de Comandos
Finalmente, Tcl recurre a otras cosas para hacer el trabajo duro. Hemos visto
que usa expr
para llevar a cabo funciones matemáticas,
que puts
maneja las operaciones de salida, y set
para asignar variables. Estos comandos Tcl están implementados por
un procedimiento C que se encuentra registrado a sí mismo dentro
de Tcl. Los procedimientos de comandos en C toman la cadena de argumentos
del comando Tcl y devuelven una nueva cadena como resultado. Es muy
fácil escribir procedimientos de comandos en C. Ellos pueden hacer
cualquier cosa, desde acceso a bases de datos hasta crear interfaces
gráficos de usuario. Tcl, el lenguaje propiamente dicho, no sabe
realmente qué hace cada comando. Tan sólo agrupa argumentos,
sustituye resultados, y ejecuta comandos.
Un último Ejemplo
Aquí tenemos el procedimiento factorial:
proc fac {x} {
if {$x < 0} {
error "Argumento erróneo $x: debe ser un entero positivo"
} elseif {$x <= 1} {
return 1
} else {
return [expr $x * [fac [expr $x-1]]]
}
}
Lecturas Complementarias
Fuente de este artículo:
Scriptics
1999-05-28, generated by lfparser version 0.6