(00.33) Ocultación de la interfase de CAhora queremos dar a nuestra librería en
Ç un formato más compacto,
de manera que las variables globales que allí pusimos, queden ocultas al programador.
Queremos que el programador solicite en forma explícita el acceso a dichas variables, sin saber sus nombrres.
Una vez que las variables han sido obtenidos, el programador podrá cambiarle los valores a su antojo, por ejemplo.
La razón de ocultar los nombres de las variables es que no queremos saturar al programador con variables ya declaradas, que puedan entrar en conflicto con otras que él tenga previamente, ya sea en otras librerías, o en su propio programa.
Aún así, lo ideal sería impedir que el programador pueda cambiar su contenido.
Esta cuestión la abordaremos más adelante...
La "ocultación" de las variables no ofrece dificultad:
Se colocan las variables deseadas en el interior de una función, que llamaremos
browcon().
Para que esas variables puedan accederse como tales, y para que sigan funcionando como antes, es decir, manteniendo su valor en forma accesible para cualquier otra función, sin que se pierdan datos en el camino,
tendremos que declararlas como
static.
Consideremos por ejemplo el caso de la variable
browcon_output.
Al declararla dentro de la función
browcon(), logramos que sea "invisible" para el programador.
Al declararla como
static, logramos que tanto su valor como la posición que ocupa en memoria, no cambien a lo largo de todo el programa.
A fin de recuperar el valor de esa variable, habrá que solicitarle a la función
browcon() que nos dé acceso a ella.
Esto sólo se puede hacer si dentro de la misma función
browcon() hay definido algún mecanismo que devuelva este dato.
Suponiendo que daremos un tal mecanismo, la devolución se hace mediante una sentencia
return.
Dado que
browcon_output es un array fijo de caracteres, su "valor" en realidad es una dirección de memoria.
Si fuese de tipo
char* (puntero a
char), esta dirección de memoria podría cambiarse, dando lugar a que el programador haga verdaderos estragos.
Esto lo evitamos definiendo la variable como de tipo
char[], que es sutilmente distinto: es un dato compatible con
char*, pero cuyo valor (dirección de memoria) no puede modificarse.
En términos técnicos, se dice en
C que no es un
lvalue, o sea, no puede ponerse del lado izquierdo de un operador de asignación.
Sin embargo, el valor de los caracteres individuales de la variable sí que pueden modificarse.
Ya veremos cómo sucede esto.
Definiremos una función browcon() que albergará variables con la información básica que queremos sostener a lo largo del programa.
Estas variables son las que teníamos antes, sólo que ahora las escondemos en la función:
char* browcon( /* parámetros... */ ) {
static char browcon_output[MAXLONGSTR] = "";
static char browcon_input[MAXLONGSTR] = "";
static char browcon_base_dir[MAXLONGSTR] = "";
static char browcon_output_file[MAXLONGSTR] = "";
static char browcon_input_file[MAXLONGSTR] = "";
// Sentencias de browcon()...
}
La función
browcon() retornará cada una de esas variables, si se lo pedimos.
Para esto, usaremos parámetros que indican a la función qué tiene que hacer.
Un primer parámetro se usará para indicarle el tipo de solicitud, y un 2do parámetro servirá para elegir la variable sobre la cual se efectuará la solicitud, o bien para anexar información adicional.
Esto se llevará a cabo con una sintaxis (sencilla) que definiremos nosotros, dentro de la misma función browcon().
¡Estamos creando un mini-mini-lenguaje!
Las solicitudes se indicarán como a través de una cadena de texto, un parámetro
char* que llamaremos
request. El 2do parámetro será también de tipo
char*, llamado param, y contendrá los detalles de la solicitud.
(Podría hacerse todo a través de un solo parámetro, con cierta sintaxis interna más compleja, pero esto complicará innecesariamente la definición de la función
browcon()).
Haremos que la solicitud
"get var" retorne una variable específica de las declaradas como static en el interior de
browcon(). Así por ejemplo, para obtener la variable browcon_output, haríamos una solicitud como ésta:
char* cadena = browcon("get var", "browcon_output");Así, la dirección de la variable cadena será ahora igual a la de
browcon_output.
Esto nos da acceso a la variabla
browcon_output, que estaba "oculta".
Y de paso vemos que es posible modificar su contenido.
Por ejemplo, para poner la cadena
"Hola mundo!" en
browcon_output, bastaría hacer ahora:
char* cadena = browcon("get var", "browcon_output");
strcpy(cadena, "Hola mundo!");
Si dentro de
browcon() imprimiéramos el valor de
browcon_output, en pantalla nos aparecería
"Hola mundo!".
¡Hemos modificado el valor de una variable interna a la función, desde afuera de ella!

Sin embargo, observemos que no es importante declarar una variable llamada cadena para poder modificar el contenido de browcon_output.
De hecho, para
C, los caracteres individuales de
browcon_output son lvalues, y por lo tanto pueden modificarse.
Podemos entonces lograr el mismo efecto escribiendo una sentencia más compacta como ésta:
strcpy(browcon("get var", "browcon_output"), "Hola mundo!");
A todos los efectos, podemos pensar que
browcon("get var", "browcon_output") es la variable
browcon_output.
La única diferencia es que no podemos escribir en nuestro programa en forma explícita el nombre de la variable, y tenemos que acceder a ella de esta forma "indirecta".
Pero
funcionan igual a nivel de programación. Son lo mismo.
Otra cuestión aquí es que, dado que el manejo de estas variables lo hacemos nosotros, no es necesario que el programador sepa exactamente cuál es el valor exacto de la variable internamente.
Nosotros podemos darle un nombre cualquiera dentro de la función, y en cambio, que se identifique de modo distinto en los parámetros de la solicitud. O sea, en vez de pasar la cadena de caracteres "browcon_output" como parámetro, pasaríamos cualquier otra cosa, como
"dame la variable esa que no recuerdo cómo se llamaba, pero que decía algo de OUT, creo...". La solicitud sería ahora:
browcon("get var", "dame la variable esa que no recuerdo cómo se llamaba, pero que decía algo de OUT, creo...")
Eso no sirve de mucho.
Lo que interesa es que la solicitud sea
breve (para no cansar al programador de tanto tipear),
y que sea
informativa (para que el programador tenga más o menos claro qué ocurre con los datos que está manipulando).
Me parece a mí que sería interesante que el programador recuerde o sepa que la variable
browcon_output es de tipo
char[].
Por brevedad, a la variable
browcon_output la identificaremos, externamente, con un nombre como
bout.
en realidad, esto no importa, pues lo que interesa es cómo se ejecuta la solicitud, y no los parámetros con que se la invoca.
Este último aspecto, más estético, es, como dijimos, para ayudar al programador.
Las cosas funcionan igual.
Así que nuestra función va tomando esta forma:
char* browcon(char* request, char* param) {
static char browcon_output[MAXLONGSTR] = "";
static char browcon_input[MAXLONGSTR] = "";
static char browcon_base_dir[MAXLONGSTR] = "";
static char browcon_output_file[MAXLONGSTR] = "";
static char browcon_input_file[MAXLONGSTR] = "";
if (strcmp(request, "get var") == 0)
if (strcmp(param, "char bout[]") == 0)
return browcon_output;
else if (strcmp(param, "char bin[]") == 0)
return browcon_input;
else if (strcmp(param, "char basedir[]") == 0)
return browcon_base_dir;
else if (strcmp(param, "char bfout[]") == 0)
return browcon_output_file;
else if (strcmp(param, "char bfin[]") == 0)
return browcon_input_file;
else
return NULL;
else
return NULL;
}
Como se ve, no hay ningún misterio en la función.
Si el primer parámetro es igual a "get var", se retorna alguna de las variables static "ocultas", según qué haya pasado como parámetro el programador.
Hemos hecho corresponder las solicitudes de la siguiente manera:
"char bout[]" -----> retorna
browcon_output.
"char bin[]" -----> retorna
browcon_input.
"char basedir[]" -----> retorna
browcon_base_dir.
"char bfout[]" -----> retorna
browcon_output_file.
"char bfin[]" -----> retorna
browcon_input_file.
La "b" es por "browcon" y la "f" es por "file", cuando corresponda.
Como se ve, el programador no tendrá ni idea ahora de cuál es el verdadero nombre de las variables internamente en la función
browcon(). Esto nos permite cambiar dichos nombres en el futuro, si nos place, sin cambiar el formato de la solicitud,
y asimismo, cambiar el formato de la solicitud sin tener que cambiar los nombres de las variables.
Nos está quedando afuera algo "colgada" la variable
browcon_errn, que es de tipo
int, y no encaja en el esquema anterior, porque las otras variables son de tipo
char*.
En principio no hay problemas en tener una variable interna
static int browcon_errn;El problema está a la hora de querer tener acceso a esa variable desde el exterior,
porque esas solicitudes las estamos resolviendo a través de una devolución con
return,
y el tipo del valor de retorno es siempre
char[], no
int.
Para que haya compatibilidad en el retorno, al menos browcon_err tiene que ser de tipo puntero o array.
Entonces, la definiremos más bien como un array de tipo
int, así:
static int browcon_errn[1];
Es un array de tamaño "1", porque nos interesa alojar sólo un número entero.
No necesitábamos más que eso.
Para acceder al valor de ese número entero, ahora tendríamos que escribir
browcon_err[0], o bien
*browcon_err, como es usual.
Pero ahora tenemos el problema de que el valor de retorno de la función, cuando hagamos
return browcon_errn;será un [b
]int*[/b] en vez de un
char*.
Para poder manejar retornos a distintos tipos de variables, vamos a cambiar el tipo de retorno a la forma genérica
void* (puntero a
void).
Este puntero genérico se usa, como sabemos, para albergar direcciones de memoria de datos del que no interesa saber su tipo.
Es el programador ahora quien tiene que ser muy cuidadoso a la hora de trabajar estos valores como si fueran de un tipo u otro.
Es la versión
C del "polimorfismo": un mismo objeto se puede comportar de modos diferentes, según la situación.
Además, si bien no es estrictamente necesario, en las sentencias
return haremos un cast a
(void*) para dejar claro que estamos convirtiendo los
char[] y los
int[] a
void*.
Luego, cuando el programador utilice estos valores de retorno, tiene que volver a hacer un cast al tipo que corresponde, por ejemplo a
(char*) o a
(int*).
Veamos cómo queda la versión modificada:
void* browcon(char* request, char* param) {
static int browcon_errn[1] = {0};
static char browcon_output[MAXLONGSTR] = "";
static char browcon_input[MAXLONGSTR] = "";
static char browcon_base_dir[MAXLONGSTR] = "";
static char browcon_output_file[MAXLONGSTR] = "";
static char browcon_input_file[MAXLONGSTR] = "";
if (strcmp(request, "get var") == 0)
if (strcmp(param, "int*berrn") == 0)
return (void*)browcon_errn;
else if (strcmp(param, "char*bout") == 0)
return (void*)browcon_output;
else if (strcmp(param, "char*bin") == 0)
return (void*)browcon_input;
else if (strcmp(param, "char*basedir") == 0)
return (void*)browcon_base_dir;
else if (strcmp(param, "char*bfout") == 0)
return (void*)browcon_output_file;
else if (strcmp(param, "char*bfin") == 0)
return (void*)browcon_input_file;
else
return NULL;
else
return NULL;
}
A todas las variables les hemos asignado un valor inicial.
Esa inicialización se hace una sola vez, en la primer ocasión que se llama a
browcon().
El adjetivo
static instruye para que no se vuelva a hacer esa inicialización en futuras llamadas a la función.
¿Cómo tenemos que hacer si queremos modificar el valor de browcon_err[0]?
Ahora se nos ha complicado la cuestión.
Una forma sería ésta:
int *n = (int*) browcon("get var", "berrn");
n[0] = 3;
O bien:
*n = 3;
Pero si por alguna razón no queremos definir variables, tendríamos que hacer esto:
((int*) browcon("get var", "berrn"))[0] = 3;Allí accedemos al primer (y único) elemento del array browcon_errn,
y le ponemos el valor 3.
Para ello, previamente hemos tenido que convertir el valor de retorno de
browcon(), que era
(void*), al tipo
(int*),
para poder asignarle un entero. Si no, podemos tener resultados indeseados.
También podemos acceder al 0-ésimo elemento del array a través del operador de indirección *, como de costumbre.
Aunque nos quedaría algo engorroso, así:
* ((int*) browcon("get var", "berrn")) = 3;Y de hecho, ésta es la manera en que lo voy a utilizar.
La misma función browcon() será utilizada para fijar valores para las variables (al menos algunas de ellas).
Esto se hará con otros tipos de solicitud.
A fin de indicar que, por ejemplo, la variable browcon_base_dir tiene que tener la cadena "C:\\programming\\C\\browcon\\",
haríamos una llamada así:
browcon("set basedir", "C:\\programming\\C\\browcon\\");En este tipo de solicitudes, no hace falta que
browcon() retorne algún valor.
Podría retornar un puntero nulo (
NULL), o bien podría retornar simplemente a la variable misma, para poder ser usada y aprovechada en llamadas anidadas con otras funciones.
Elegiré este último enfoque.Además, agregaremos una solicitud
"start", con la intención de inicializar de algún modo los objetos dentro de
browcon().
Como esta inicialización se hace ya al declarar las variables, no hay por ahora nada especial que hacer.
Así que dicha solicitud no hará nada, y simplemente retornará
NULL.
Pero en realidad sí que hace algo.
Si hacemos siempre una primera llamada a
browcon() con la solicitud
"start", por ser la 1er llamada a la función, los valores de las variables quedarán allí inicializados. Algo es algo.
No tengo claro ahora si las variables
static se inicializan cuando arranca el programa, o sólo cuando se llama a la función por primera vez.

Me queda pendiente de tarea...
La función completa nos queda ahora así:
void* browcon(char* request, char* param) {
static int browcon_errn[1] = {0};
static char browcon_output[MAXLONGSTR] = "";
static char browcon_input[MAXLONGSTR] = "";
static char browcon_base_dir[MAXLONGSTR] = "";
static char browcon_output_file[MAXLONGSTR] = "";
static char browcon_input_file[MAXLONGSTR] = "";
if (strcmp(request,"start") == 0)
return NULL;
else if (strcmp(request, "get var") == 0)
if (strcmp(param, "int berrn[]") == 0)
return (void*)browcon_errn;
else if (strcmp(param, "char bout[]") == 0)
return (void*)browcon_output;
else if (strcmp(param, "char bin[]") == 0)
return (void*)browcon_input;
else if (strcmp(param, "char basedir[]") == 0)
return (void*)browcon_base_dir;
else if (strcmp(param, "char bfout[]") == 0)
return (void*)browcon_output_file;
else if (strcmp(param, "char bfin[]") == 0)
return (void*)browcon_input_file;
else
return NULL;
else if (strcmp(request, "set basedir") == 0)
return (void*)strcpy(browcon_base_dir, param);
else if (strcmp(request, "set bfout") == 0)
return (void*)strcat(strcpy(browcon_output_file, browcon_base_dir), param);
else if (strcmp(request, "set bfin") == 0)
return (void*)strcat(strcpy(browcon_input_file, browcon_base_dir), param);
else
return NULL;
}
Observemos que, por defecto, la función retorna
NULL.
Es importante que siempre haya un valor de retorno concreto cuando se está trabajando con punteros,
porque si no pueden producirse accesos imprevistos a lugares indeseados de la
memoria RAM, haciendo que el programa se bloquee.
Queremos ahora ocultar al programador también las operaciones de escritura y lectura de archivos.
Lo haremos con una nueva función "controladora y ocultadora" como la anterior.
Se llamará
fbrowcon() (la "f" es por "file" = "archivo"), y actuará respondiendo a solicitudes, igual que hicimos con
browcon():
#define BROWCON_OUTPUT_FILENAME "browcon.output.txt"
#define BROWCON_INPUT_FILENAME "browcon.input.txt"
void* fbrowcon(char* request, char* filename, char* buffer) {
if (strcmp(request,"start") == 0) {
browcon("start",NULL);
browcon("set basedir", filename);
browcon("set bfout", BROWCON_OUTPUT_FILENAME);
browcon("set bfin", BROWCON_INPUT_FILENAME);
return NULL;
} else if (strcmp(request,"write plain text line") == 0) {
FILE* F;
while ( !(F = fopen(filename, "w")) )
;
// F != NULL, file 'filename' open for writing
int* n_ = (int*)browcon("get var", "int berrn[]");
*n_ = fputs(buffer, F);
while (fclose(F) == EOF)
;
return n_;
} else if (strcmp(request,"read plain text line") == 0) {
FILE* F;
// size(buffer) >= MAXLONGSTR
while ( ! (F = fopen(filename, "r")) )
;
// F != NULL, file 'filename' open for reading
fgets(buffer, MAXLONGSTR, F);
while (fclose(F) == EOF)
;
return (void*) buffer;
} else
return NULL;
}
El primer parámetro de
fbrowcon() es de una cadena de texto,
char* request, en la que se informa el tipo de solicitud.
Hemos definido las solicitudes
"start",
"write plain text line",
"read plain text line".
El 2do parámetro se usa para informar el nombre de archivo sobre el que se procesará la solicitud.
En el caso de lectura/escritura de archivos, es claro que esto significa el nombre del archivo que leeremos o escribiremos.
Pero en el caso de la solicitud
"start", lo que se espera en el parámetro
char* filename es la ruta del directorio base en el que se va a trabajar.
Así, es importante que en nuestro programa llamemos a esta función al principio de todo, para inicializar correctamente dicha ruta.
Si no, nada funcionará bien.El 3er parámetro se refiere a la información misma que se procesará en el archivo.
En el caso de una solicitud de escritura de datos, el parámetro
char* buffer contendrá una cadena de caracteres que será enviada al archivo
"console.output.txt".
Esta cadena puede desecharse luego de haber enviado los datos para escritura.
En el caso de una solicitud de lectura de datos, el parámetro
char* buffer necesita recibir una variable externa con espacio suficiente para almacenar datos allí. Esta vez
buffer no puede desecharse.
Finalmente, en el caso de una solicitud
"start", no importa qué se haya pasado como parámetro en
buffer,
pero lo recomendable (digo yo

) en este caso es llamar a la función con ese parámetro puesto a
NULL.
Notemos que, otra vez, el valor de retorno de
fbrowcon() es de tipo
void*,
y que esto nos obliga a hacer conversiones y desconversiones, según los casos, hacia/desde
(char*) ó
(int*).
Para mayor brevedad, voy a cambiar aquí los nombres de las funciones
browcon_puts() y
browcon_gets() a
bcputs() y
bcgets(), respectivamente.
Ahora estas funciones hacen solicitudes a
fbrowcon(). Quedan así:
int bcputs(char* s) {
return *((int*) fbrowcon("write plain text line", (char*)browcon("get var", "char bfout[]"), s));
}
char* bcgets(char* s) {
return (char*) fbrowcon("read plain text line", (char*)browcon("get var", "char bfin[]"), s);
}
Observemos cómo ahora, mediante un cast
*((int*) ...) hemos podido lograr el objetivo de enviar un humilde y sencillo
int como valor de retorno de
bcputs(), a fin de que actúe de forma análoga a la función estándar
puts() de
stdio.h.
Las macros ahora se llamarán
bcprintf() y
bcscanf(), para más brevedad.
Estas macros las hemos definido de manera que "retornen" un valor, que es un
int en ambos casos,
con el mismo significado que el valor retornado por
printf() y
scanf().
Como toda la macro es una "expresión" que evalúa a un
int, no podemos hacer ciertas declaraciones allí adentro.
En particular, no podemos declarar variables.
Y por eso nos vemos obligados a hacer manipulaciones extrañas con casts y con indirecciones.
El resultado es esto:
#define bcprintf(...) ( \
sprintf(browcon("get var", "char bout[]"), __VA_ARGS__), \
*( (int*) browcon("get var", "int berrn[]") ) = bcputs(browcon("get var", "char bout[]")) \
)
#define bcscanf(...) \
(*((int*) browcon("get var", "int berrn[]") ) = sscanf(bcgets(browcon("get var", "char bin[]")), __VA_ARGS__))
Hemos completado las modificaciones, y esto constituye la
versión 00.33 de la
browcon.
De nuevo, no hacemos modificaciones a la parte de
JavaScript.
El código completo, en spoiler:
(browcon00.33.h)
// Browcon 00.33
// 2013/May/12
#include <stdio.h>
#include <string.h>
#define MAXLONGSTR 1023
void* browcon(char* request, char* param) {
static int browcon_errn[1] = {0};
static char browcon_output[MAXLONGSTR] = "";
static char browcon_input[MAXLONGSTR] = "";
static char browcon_base_dir[MAXLONGSTR] = "";
static char browcon_output_file[MAXLONGSTR] = "";
static char browcon_input_file[MAXLONGSTR] = "";
if (strcmp(request,"start") == 0)
return NULL;
else if (strcmp(request, "get var") == 0)
if (strcmp(param, "int berrn[]") == 0)
return (void*)browcon_errn;
else if (strcmp(param, "char bout[]") == 0)
return (void*)browcon_output;
else if (strcmp(param, "char bin[]") == 0)
return (void*)browcon_input;
else if (strcmp(param, "char basedir[]") == 0)
return (void*)browcon_base_dir;
else if (strcmp(param, "char bfout[]") == 0)
return (void*)browcon_output_file;
else if (strcmp(param, "char bfin[]") == 0)
return (void*)browcon_input_file;
else
return NULL;
else if (strcmp(request, "set basedir") == 0)
return (void*)strcpy(browcon_base_dir, param);
else if (strcmp(request, "set bfout") == 0)
return (void*)strcat(strcpy(browcon_output_file, browcon_base_dir), param);
else if (strcmp(request, "set bfin") == 0)
return (void*)strcat(strcpy(browcon_input_file, browcon_base_dir), param);
else
return NULL;
}
#define BROWCON_OUTPUT_FILENAME "browcon.output.txt"
#define BROWCON_INPUT_FILENAME "browcon.input.txt"
void* fbrowcon(char* request, char* filename, char* buffer) {
if (strcmp(request,"start") == 0) {
browcon("start",NULL);
browcon("set basedir", filename);
browcon("set bfout", BROWCON_OUTPUT_FILENAME);
browcon("set bfin", BROWCON_INPUT_FILENAME);
return NULL;
} else if (strcmp(request,"write plain text line") == 0) {
FILE* F;
while ( !(F = fopen(filename, "w")) )
;
// F != NULL, file 'filename' open for writing
int* n_ = (int*)browcon("get var", "int berrn[]");
*n_ = fputs(buffer, F);
while (fclose(F) == EOF)
;
return n_;
} else if (strcmp(request,"read plain text line") == 0) {
FILE* F;
// size(buffer) >= MAXLONGSTR
while ( ! (F = fopen(filename, "r")) )
;
// F != NULL, file 'filename' open for reading
fgets(buffer, MAXLONGSTR, F);
while (fclose(F) == EOF)
;
return (void*) buffer;
} else
return NULL;
}
int bcputs(char* s) {
return *((int*) fbrowcon("write plain text line", (char*)browcon("get var", "char bfout[]"), s));
}
char* bcgets(char* s) {
return (char*) fbrowcon("read plain text line", (char*)browcon("get var", "char bfin[]"), s);
}
#define bcprintf(...) ( \
sprintf(browcon("get var", "char bout[]"), __VA_ARGS__), \
*( (int*) browcon("get var", "int berrn[]") ) = bcputs(browcon("get var", "char bout[]")) \
)
#define bcscanf(...) \
(*((int*) browcon("get var", "int berrn[]") ) = sscanf(bcgets(browcon("get var", "char bin[]")), __VA_ARGS__))
Para testear esta librería, podemos hacerlo con un programa de testeo adecuado, el siguiente:
// testbc02.c
#include <stdio.h>
#include "browcon00.33.h"
int main(void) {
printf("Estableciendo ruta y archivos...\nPresione Enter para continuar en cada paso.\n\n");
fbrowcon("start","C:\\programming\\C\\browcon\\",NULL);
printf(browcon("get var","char basedir[]"));
printf("\n");
printf(browcon("get var","char bfout[]"));
printf("\n");
printf(browcon("get var","char bfin[]"));
printf("\n");
getchar();
printf("Enviando...\n");
bcprintf("Enviando una cadena de texto común y corriente.");
printf(" Ahora...\n");
bcprintf(" Ahora enviamos datos formateados: %i %i %s %i.", 1, 22, "hello!", 333);
getchar();
int a, b, c; char s[100];
printf("(Llamada a scanf...)\n");
getchar();
bcscanf("%i %i %s %i", &a, &b, s, &c);
printf("Datos leídos: %i %i %s %i\n", a, b, s, c);
getchar();
}
Notemos la llamada a
fbrowcon("start", ...) para inicializar el directorio base antes de las operaciones.
En algún momento futuro, intentaremos que esa llamada sea innecesaria.
Lo más gracioso de todo esto... es que ¡funciona!

'Ta lindo...