Para invocarlo desde Tcl no hay más que hacer:

En casos más complejos se le pueden pasar argumentos de la misma forma que se haría desde DOS:

Y en caso de necesidad se puede usar catch por si se produce algún error durante la ejecución:

Incluso se pueden redireccionar los streams de entrada, salida y error:

Exec solamente sirve para casos sencillos, en los que no es necesario una comunicación continuada entre el script en Tcl y el programa en C (o C++, Pascal, ...). En caso de que sea necesaria, se puede usar el comando Tcl open con la opción "|" para ejecutar un programa y comunicarse con él usando la entrada y la salida estándar. El programa debe ser escrito de forma que realice todo el intercambio de datos a través de la salida y la entrada estándar con datos de tipo ASCII. Una vez que se haya comprobado que funciona correctamente desde DOS hay que escribir en Tcl script que nos de acceso al programa:

Los comandos puts y gets pueden repetirse tantas veces como sea necesario. Una vez que hayamos acabado con el programa, le mandamos una orden para que se suicide sin dejar rastro y cerramos la tubería.

Si bien para casos sencillos se pueden emplear los métodos ya comentados, a medida que se complica la parte correspondiente a la programación en C es mejor crear nuevos comandos Tcl cuya implementación se hace en C, y que podrán se usados igual que si fuesen comandos originales o procedimientos de Tcl.

La distribución de Tcl/Tk incluye una extensa librería de funciones que permiten realizar la implementación de en C de comandos Tcl. El uso de esta librería no es realmente complicado pero, al requerir el seguimiento de una serie de pasos bastante rígido, por parte del programador, puede parecerlo en un principio.

• Compilando un nuevo interprete de Tcl/Tk con los nuevos comandos y que usaremos en lugar de wish para interpretar el script de Tcl.
• Creando una librería dinámica, .DDL en Windows, .so en Unix, con la definición de los nuevos comandos e incorporándola al intérprete con el comando load.

Afortunadamente, la librería de que dispone Tcl/Tk es demasiado extensa como para poder comentar aquí todas las funciones que la componen; por ello sólo se comentarán las más importantes para poder realizar aplicaciones simples (y no tan simples), el resto se pueden encontrar el la ayuda de Tcl.

Para crear el nuevo intérprete es necesario seguir tres pasos:

• Inicialización
• Definición de los nuevos comandos.
• Comienzo de la ejecución de programa.

De la inicialización se encargan las funciones:

o también:

según que el programa que vayamos a escribir necesite únicamente Tcl o también Tk. Los dos primeros parámetros son los mismos que los de la función main, mientras que el tercero es un puntero a una función definida por el usuario en la que se terminará la inicialización, a esta función se la suele llamar Tcl_AppInit, pero puede usarse cualquier nombre.

El prototipo de esta función es:

Tcl_interp es una estructura definida en <tcl.h> que nos va a servir para pasar información a las funciones que implementan nuestros comandos y para recibir los resultados de ellas.

Lo primero que hay que hacer en esta función es llamar a las funciones Tcl_Init y Tk_Init que se encargan de inicializar el intérprete con los comandos originales de Tcl y Tk; en el caso de Tk_Init se encarga ,además, de crear la ventana principal de la aplicación.

Los prototipos de estas funciones:

El parámetro que hay que pasarles es el mismo ‘interprete’ que recibió la función Tcl_AppInit. En cuanto al entero que devuelven estas funciones, puede tomar los valores:

• TCL_OK, si todo va bien.
• TCL_ERROR, si se produce algún error.

Una vez que ya tenemos el interprete inicializado se pasa a la definición de los comandos que queramos implementar; para ello se usa la función Tcl_CreateCommand, cuyo prototipo es:

• interprete: el mismo de siempre.
• NombreCmd: el nombre que le vayamos a dar al comando Tcl.
• proc: puntero a la función que implementa el comando; o sea, el mismo nombre de la función
• clientdata: una palabra arbitraria que se le pasa a proc y deleteProc.
• deleteProc: procedimiento a invocar antes de que el comando sea borrado del intérprete.

Normalmente a estos dos últimos parámetros se les pasa NULL.

En cuanto a la implementación de las funciones, el prototipo de las funciones que lo hagan debe ser:

los parámetros que se le pasan al comando Tcl definido vienen en argc y argv de la misma forma que en la función main de C, es decir, en argc el número de parámetros incluyendo el nombre del comando y cada elemento de la matriz argv contiene un puntero la cadena en la que está el parámetro correspondiente. La función devuelve un entero: TCL_ERROR o TCL_OK según haya habido o no un error.

En caso de que los parámetros pasados al comando no sean cadenas sino enteros o reales, se usan las siguientes funciones para hacer la transformación:

todas ellas devuelven TCL_OK si se pudo hacer la transformación, y TCL_ERROR en caso contrario.

Si alguno de los parámetros es una lista, se puede separar en su componentes por medio de la función:

Para devolver valores al intérprete se usa Tcl_SetResult:

• interprete: el que se haya pasado a la función.
• string: la cadena que se devuelve como resultado del comando.
• freeProc: puede ser:

• TCL_STATIC: si la cadena es estática
• TCL_VOLATILE: si la cadena es una variable local a la función
• TCL_DYNAMIC: si la cadena se ha dimensionado con malloc; en este caso TCL se encarga de liberar la memoria cuando ya no necesite el resultado. Para asegurar el buen funcionamiento en todas las plataformas y para todos los compiladores, es conveniente usar Tcl_Alloc o Tcl_Realloc junto con Tcl_Free.

En caso de que el valor a devolver sea una lista, se usan las funciones Tcl_AppendElement y Tcl_AppendResult.

Una vez que se ha completado la inicialización del programa, se puede invocar un script Tcl con lo que comenzará la ejecución del programa propiamente dicho; para ello se usa una sentencia del tipo:

donde "~/" representa el directorio "hogar" del usuario y script es el fichero Tcl que va a ser invocado. En caso de que no se indique ninguno, el programa se ejecutará igual que lo hace wish. En Windows el directorio donde se encuentra el fichero se indicará: "c:/path_tcl/script".

Llegados a este punto, vamos a pasar al ejemplo. Vamos a crear un intérprete con los siguientes nuevos comandos:

• hola: escribirá en la pantalla ‘ˇHola mundo!!’
• media: calculará la media de los números que se encuentren en la lista que se le pase como parámetro.

En primer lugar, por ser más sencillo, se va a hacer para el caso de un sistema operativo de tipo UNIX y a continuación para Windows

Una vez compilado el programa, más tarde se verá cómo, al ejecutarlo, aparentemente es como si estuviéramos usando el wish; todo es igual hasta que usamos los comandos hola y media {1 2 3 4 5}, incluso podemos usar comandos de Tk como button etc., es decir, tenemos un intérprete completo de Tcl/Tk más los comandos definidos por nosotros, un intérprete que podremos usar de la misma forma que wish, tanto interactivamente como en un script de Tcl, sin más que poner en la primera línea:

Con la distribución de Tcl se incluye un fichero llamado tclAppInit.c en el que se incluye un modelo de función Tcl_AppInit más complejo del aquí indicado que se puede usar como ejemplo.

Para el caso de Windows el programa queda:

Al igual que para el caso de Unix, se puede encontrar un modelo para la función WinMain en la distribución de Tk, en el fichero winMain.c, pero no con la que viene precompilada, sino con la distribución completa sin compilar; en este fichero se encuentra también la función setargv que no se ha incluido en el ejemplo para ahorrar espacio. Asimismo, las funciones relativas a la consola se pueden encontrar en el fichero tkConsole.c que también se incluye con la distribución sin compilar; por último, la función media es la misma del ejemplo anterior.

Las funciones de la consola sólo son necesarias si se quiere usar esta, en caso contrario se quitan y ya está.

La estructura Tcl_interp contiene un campo llamado result que se usa para contener el resultado de comando; la longitud de este campo es originalmente de unos 200 bytes; se puede, en teoría, escribir el resultado directamente en él sin necesidad de usar la funciones de la familia Tcl_SetResult. Por ejemplo, en la función media se podría haber puesto:

esta forma de especificar el resultado ya estaba desaconsejada en anteriores versiones de Tcl, a partir de la versión 8.0 , por motivos que veremos más adelante, "se desaprueba fuertemente".

Tcl_Eval

En el ejemplo del apartado anterior se muestra un "Hola mundo" que es claramente decepcionante para cualquier entorno gráfico que se precie; lo menos sería ponerlo en una ventana con un botón de aceptar y demás, algo así como:

Para conseguir este resultado sin necesidad de recurrir a la librería en C de Tk se usan las funciones de la familia Tcl_Eval. El prototipo del función Tcl_Eval es:

donde interprete es el que estemos usando y comando es la instrucción TclTk que queremos evaluar. Esta instrucción se puede usar en la función que implementa un comando sin que produzca ningún tipo de interferencia entre ambos comandos.

Existen varias funciones relacionadas con Tcl_Eval, como son Tcl_RecordAndEval que permite guardar el comando que se va a ejecutar de forma que pueda ser recuperado con el comando de Tcl history, Tcl_EvalFile que permite a su vez evaluar el contenido de un fichero; por ejemplo como el que contiene la ventana para saludar al mundo que acabamos de hacer. Para usarlo, modificamos la función hola del ejemplo 23-3

Variables compartidas entre C y Tcl

En ocasiones puede ser interesante comprobar directamente el valor de una variable en Tcl desde la parte en C del programa o viceversa, incluso unir una variable en C y una en Tcl de forma que contengan siempre el mismo valor, es decir, que al cambiar una, la otra lo haga automáticamente. Por ejemplo, esto nos puede valer para tener una variable booleana que nos diga si estamos conectados a una base de datos o no.

Para ello tenemos las funciones:

que fijan el valor de una variable, Tcl_SetVar2 se usa en caso de matrices, aunque también sirve Tcl_SetVar si el nombre de la variable incluye el índice entre paréntesis. En el ejemplo 23-3 se usa Tcl_SetVar para que Tcl supiera qué script utilizar al inicializarse.

Análogamente, las siguientes funciones devuelven el valor de una variable Tcl:

Mientras que estas eliminan variables:

Por último, las siguientes funciones se usan para unir variable Tcl y C:

Compilación de los programas

Lógicamente el método de compilación dependerá de la plataforma y el compilador elegido.

En Unix habrá que usar un fichero make del estilo del que se muestra en el ejemplo 23-6

claro que sólo funcionará si los directorios indicados para las librerías coinciden con los de la plataforma en que se use. En caso contrario, puede preguntarse al administrador del sistema dónde se encuentran, aunque normalmente el administrador preferirá que se los busque uno mismo con find.

La forma de compilación varía entre los distintos sistemas, así por ejemplo, en Linux es necesario incluir la librería libdl.so.x.yy, donde la X y las YY indican el número de versión. Esto se debe a la forma en que están compiladas las librerías en la distribución slackware.

En Windows 95 y NT, lo más frecuente es usar los entornos integrados de desarrollo de Microsoft o de Borland:

• Borland C++ Builder: lo primero que hay que hacer a la hora de crear el nuevo proyecto es decir que se va a realizar una aplicación de consola; sin embargo, en las opciones del proyecto, en Linker, en el tipo de aplicación hay que escoger Windows GUI, además en Directories, en el path de los ficheros include hay que añadir el correspondiente a tcl.h y tk.h. Por último, hay que incluir en el proyecto las librerías tcl80.lib y tk80.lib.
• Visual C++: una vez creado el proyecto, añadido el directorio de los ficheros include e incluido las librerías, en el menú Build submenú Settings pestaña Proyect Options hay que cambiar la opción de compilación /subsystem:console por /subsystem:windows. En este caso las librerías a usar son tcl80vc.lib y tk80vc.lib.

Como ya se indicó al principio del capítulo, se puede usar el comando load de Tcl para cargar un fichero que contenga un paquete de comandos, los inicializa y los incorpora al interprete. Su sintaxis es:

El tipo de fichero varía de unos sistemas a otros, pero normalmente consiste en una librería compartida, .so en Unix .dll en Windows.

Una vez que se carga el fichero, se invoca a un procedimiento que inicialice el paquete. El nombre de esta función viene dado por el nombre del paquete; por ejemplo, si se llama estadistica, deberá incluir una función de inicialización llamada Estadistica_Init, cuyo prototipo será:

Load también puede usarse para el caso de paquetes que se hayan lincado estáticamente con la aplicación, declarándolos con la función Tcl_StaticPackage.

En cuanto a cómo realizar un DLL, lo mejor es consultar la documentación del compilador que vaya a usarse. También puede consultarse un ejemplo que se encuentra en Internet junto con las distribuciones de Tcl, en un fichero llamado example.zip.

Objetos

En su momento se comentó que en Tcl el único tipo de datos que existía eran las cadenas, sin embargo, a partir de la versión 8.0, Tcl usa, además, internamente los llamados objetos. Estos objetos se usan para almacenar variables, los argumentos que se pasan a los comandos así como los resultados. Los objetos se comportan como cadenas, pero internamente tienen una representación de los datos con la que se puede operar de forma más eficiente ya que varía según el tipo de dato de que se trate.

Cada una de las dos representaciones de los datos contenidos en un objeto se calculan únicamente cuando son necesarias. Por ejemplo, si tenemos un objeto que representa un entero, se pueden estar haciendo operaciones con él sin necesidad de volver a calcular cada vez la representación del entero como cadena, lo que no se hará hasta que explícitamente se necesite la cadena; esto permite una mayor rapidez en los cálculos, ya que no hay que hacer la transformación de cadena a entero y viceversa cada vez que se use en una operación.

Cuando se cambia cualquiera de las representaciones de un objeto, la otra se invalida, aunque no vuelve a calcularse hasta que sea necesario. Por ello no es conveniente acceder directamente a los campos de la estructura que componen un objeto; es por ello también, por lo que prácticamente se prohibe escribir los resultados de una función directamente en "interprete->result", tal y como se comentó anteriormente.

Para manipular un objeto como si fuera una cadena, se usan funciones como:

que crea un nuevo objeto que contendrá la cadena y devuelve un puntero al objeto creado,

modifica la cadena contenida en un objeto,

devuelve un puntero, que no debe ser modificado, a la cadena contenida y cuya longitud se indica en longitud_cadena.

Estas funciones se "repiten" para los distintos tipos posibles de objetos, así tenemos:

Las peculiaridades de cada tipo se pueden consultar en las páginas de ayuda correspondientes.

Los objetos lo invaden todo en la nueva versión de Tcl ,así para definir un comando de Tcl en C, además de usar Tcl_CreateCommand se puede usar Tcl_CreateObjCommand, se diferencian a la hora de invocar la función correspondiente. La versión antigua, como ya se ha explicado, pasa el valor de los parámetros a la función en una matriz de punteros a cadenas de caracteres; pues bien, en la versión moderna lo hace en una matriz de punteros a objetos, así, si los parámetros son, por ejemplo reales, como los objetos tienen una representación interna adecuada, resulta que todo es más eficiente.

También se usan objetos para devolver resultados a Tcl desde un comando implementado en C, así tenemos:

equivalente a Tcl_SetResult para objetos.

En realidad las funciones mencionadas anteriormente, tales como Tcl_SetResult, Tcl_AppendElement y Tcl_AppendElement no es que no puedan usarse, pero es mejor, en la medida de lo posible, usar las nuevas basadas en objetos ya que son más eficientes, aunque a decir verdad, si tuviéramos prisa no usaríamos TclTk, así que se pueden seguir usando.

Por ejemplo, si tenemos un comando que debe devolver una lista de enteros, tendríamos que definir un nuevo objeto del tipo lista con Tcl_NewListObj, construir la lista con Tcl_ListObjAppendElement, y finalmente fijar el resultado con Tcl_SetObjResult.

También hay una nueva versión de Tcl_Eval llamada, con la originalidad habitual, Tcl_ObjEval, de prototipo:

donde el objeto contiene una cadena con uno o varios comandos. En realidad, Tcl_Eval está implementada en la nueva versión mediante Tcl_ObjEval, por lo que es más rápido usarla directamente.

Como ejemplo de programación con objetos vamos a hacer un interprete con dos nuevos comandos:

• media, como en el ejemplo 23-3 pero con objetos
• divisores, dado un numero entero, devuelve una lista con sus divisores