Autor Tema: Interacción entre C y JavaScript+ActiveX (proyecto: usar navegador como consola)

0 Usuarios y 1 Visitante están viendo este tema.

12 Mayo, 2013, 01:31 am
Respuesta #10

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.30) Procesando archivos con datos reales

Vamos a agregar aquí la capacidad de leer y escribir archivos de texto.

El modo más sencillo de interactuar con otras aplicaciones es tomando datos almacenados en archivos del disco rígido. Esto es así porque todos los lenguajes de programación incluyen algún modo de leer y escribir archivos.
En cambio, es más complicado intercambiar datos almacenados en la memoria, o en registros del sistema operativo, o variables del entorno.

Un modo rápido de intercambiar información entre C y JavaScript podría ser el uso de variables del entorno del sistema operativo.
Pero me he encontrado con dificultades. Por ejemplo, dichas variables se almacenan temporalmente en sesiones locales de cada programa, y no se pueden intercambiar.

Tras varias vueltas, me decidí por la lectura y escritura de archivos de texto en disco, que es una operación clara y segura, que tanto C como JavaScript pueden llevar a cabo... Eso sí, en JavaScript necesitamos la ayuda de la librería ActiveX, pues de otro modo es imposible que JavaScript realice acciones de lectura/escritura en disco.



Habiendo decidido esto, es natural definir funciones genéricas que se encarguen de leer el contenido completo de un archivo de texto y guardarlo en una cadena de texto, y también escribir una cadena de texto en un archivo.

Primero definimos una función auxiliar que pregunta si un determinado archivo está vacío.
En caso contrario, podremos leer su contenido, si no, devolvemos la cadena vacía.
Esto puede ser necesario de verificar en el caso de que, por ejemplo, estemos intentando leer un archivo que no existe.
Así, evitamos problemas en las operaciones de lectura.


            function file_isempty(filename) {
                return ((new ActiveXObject("Scripting.FileSystemObject")).GetFile(filename).Size == 0);
            }

            function ReadTextFile(filename) {
                var content = "";
                var f = (new ActiveXObject("Scripting.FileSystemObject")).OpenTextFile(filename, 1, true, false);
                if (!file_isempty(filename)) {
                     content = f.ReadAll();
                }
                f.Close();
             
                return content;
            }
           
            function WriteTextFile(filename, sData) {
                var f = (new ActiveXObject("Scripting.FileSystemObject")).CreateTextFile(filename, true, false);
                f.write(sData);
                f.Close();
            }


Las tres funciones toman como parámetro una cadena de texto filename que contendrá el nombre de archivo.
La función file_isempty() devuelve un valor booleano true, si el archivo está vacío, y false en otro caso.
La función ReadTextFile() lee el contenido completo de un archivo de texto en una cadena de texto, la cual retorna como resultado de la operación.
La función WriteTextFile() abre un archivo de texto con nombre filename, y le escribe encima los datos de la cadena de texto sData. Si había datos previamente en el archivo, éstos se pierden indefectiblemente.

En todos los casos se respeta la recomendación general, en todo lenguaje de programación, de cerrar los archivos una vez completadas las operaciones que se han hecho sobre ellos.
Esto se lleva a cabo mediante el método Close().



Ahora bien.
Necesitamos que sea el lenguaje C quien envíe la petición de escribir o leer archivos.
Pero como todavía no abordaremos esto, seguiremos con los botones que simulan peticiones ficticias de entrada/salida.

Pero ahora vamos a leer y escribir datos en archivos reales.

Primero que nada, decidamos en qué carpeta del disco rígido vamos a alojar estos archivos.
Lo haremos en la misma carpeta en que se encuentra la browcon.
No interesa cuál es esta carpeta, porque con JavaScript/ActiveX podemos obtener esta información,
y así no nos veremos obligados a modificar nuestro código cada vez que se nos ocurra cambiar de carpeta nuestro proyecto.

La ubicación de la página web (en nuestro caso, la browcon) puede obtenerse leyendo el atributo window.location.href.
Dado que la browcon la estamos alojando en nuestra computadora, aparecerá antepuesto a la dirección URL el prefijo 'file:///'.
Simplemente quitaremos esa parte de la dirección invocando el método replace('file:///','').
El resultado lo alojaremos en una variable temporal (tipo string) temp, y procuraremos dejar sólo el directorio base, quitándole el nombre del documento actual.
¿Cómo logramos esto?
Bueno, notemos que la dirección URL de nuestra browcon contiene todo el camino de carpetas separadas por '/' a las que es necesario acceder hasta llegar a la última, que contiene el archivo browcon00.30.html.

Así, buscamos la última aparición del caracter '/', y borramos lo que sea que haya a su derecha.
O bien, nos quedamos con todo lo que hay a su izquierda.
Las siguientes sentencias hacen el trabajo:


            temp = window.location.href.replace("file:///","");
            base_dir = temp.slice(0,1 + temp.lastIndexOf("/"));


El método slice() lo usamos para tomar la porción de la cadena de texto que nos interesa guardar.



Elegimos nombres para los archivos de texto que usaremos a modo de consolas de entrada y salida:


            browcon_output = base_dir + 'browcon.output.txt';
            browcon_input  = base_dir + 'browcon.input.txt';


Observamos que los archivos quedarán almacenados en la misma carpeta en que tenemos alojada la browcon, pues les hemos antepuesto dicha carpeta base al nombre de archivo.

Cuando la browcon reciba una señal de que debe imprimir datos en la consola de salida,
en vez de enviar la cadena test que usábamos hasta ahora, enviaremos el contenido completo del archivo de texto browcon_output.
Para esto, leemos el contenido del archivo con la función ReadTextFile(), y lo enviamos al bloque divprintf con la función post().

Toda esa explicación para una sentencia sencilla:


                        if (signal_divprintf) {
                            signal_divprintf = false;
                            post(ReadTextFile(browcon_output));
                        };


Vemos que sólo ha cambiado la tercer línea, la de post(...).



Cuando la browcon recibe una señal de petición de entrada de datos, sólo se hace visible el casillero de texto correspondiente, y nada más.
Se espera luego a que el usuario ingrese algún dato, y sólo cuando ha presionado Enter es que se llamaba a la función senddata().
Es en este momento, dentro de la función senddata(), que haremos el envío de datos al archivo browcon_input.

Lo haremos antes del respectivo eco que enviamos a la "pantalla".
Así sólo agregamos una línea de código, y la función senddata() queda ahora así:


           function senddata(str) {                                         
                show_divscanf = false;
               
                WriteTextFile(browcon_input, str);
                 
                post('<span style="color:DarkBlue"><b>' + prevent_html(str) + '</b></span>' + '<br />');
                document.getElementById('inputscanf').value = '';

                InputActive = false;
           }


El contenido del archivo browcon.output.txt tendremos que ponerlo a mano por ahora.
Pacientemente, abriendo un editor de texto, escribimos el texto que más nos guste.
Y tras clickear el botón "Send data..." de nuestra browcon, el contenido del archivo aparecerá en el navegador como por arte de magia.

Para que esto funcione siempre bien, hay que recordar "guardar" el archivo de texto en el editor.
Yo puse el siguiente texto en browcon.output.txt:


Esto es un texto cualquiera,
escrito en el archivo browcon.output.txt.
Esto tiene que visualizarse correctamente en la browcon,
tras recibir una petición de muestreo de datos.
También se puede enviar código HTML activo, por ejemplo:
¿Formateado? <span style='color:red'><b>¡ROJO CON NEGRITA!</b></span>


Tras presionar varias veces el botón "Send data...",
y tras enviar el texto "¡¡Hola mundo!!" mediante el botón "Get data...",
obtuve la imagen de la foto, y además el archivo browcon.input.txt fue modificado correctamente por la browcon para alojar el texto "¡¡Hola mundo!!":




Observamos que todo funciona muy bien, pero que en particular los "saltos de línea" son interpretados como un caracter " " (espacio en blanco).
Esto es así debido al modo particular en que HTML interpreta y acomoda los espacios en blanco.
Digamos que, básicamente, ignora los saltos de línea, y también ignora los blancos excesivos.

Para tener un control más directo sobre estos caracteres, tendremos que hilar más fino en nuestras habilidades de programación.
No es tanto un problema técnico (que puede resolverse fácilmente tanto desde C como desde JavaScript), como de decisión de diseño.
Lo discutiremos después.

(Por ahora, digo Fernández, lo importante es que ande).



Finalmente, adjuntamos la nueva versión de browcon, para descarga.

browcon00.30.html


12 Mayo, 2013, 06:26 am
Respuesta #11

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.31) Interacción manual con C

Ya es tiempo de que programemos un poco en C.

Como es natural, necesitaremos algunas funciones parecidas a las de entrada/salida que ya hemos definido en JavaScript.

Debido a que vamos a correr simultáneamente dos procesos, uno en JavaScript y otro en C, y ambos van a intentar leer o escribir sobre los mismos archivos, hay que anticiparse a este posible conflicto, tomando algunas precauciones.

(1ero) Cuidaremos que C y JavaScript no escriban datos en los mismos archivos.

Como la operación de escritura de un archivo cambia el contenido de éste, puede darse un resultado impredecible si hay más de un proceso poniendo información ahí.
Así que diseñaremos nuestras rutinas de manera que no exista esta superposición.
En particular, nos las tendremos que ingeniar para compartir información entre C y JavaScript, sin que ambos "se toquen".

(2do) Se tendrá especial cuidado en la apertura de archivos, para evitar conflictos.

Debido a que probablemente más de un proceso a la vez esté intentando acceder a un mismo archivo,
es probable que se produzcan constantemente errores al intentar abrir esos archivos en C.
Por eso es necesario tomar medidas profilácticas, asegurando que no se realizan operaciones de lectura/escritura de archivos hasta que C ha podido abrir el archivo sin problemas.

Puede ocurrir que C esté intentando escribir en un archivo que JavaScript está leyendo, o viceversa.
Esto no acarrearía problemas, creo yo, debido a que las operaciones de lectura "son inofensivas", por decirlo de algún modo.
Además, quisiéramos confiar en que el sistema operativo se encargará de gestionar las operaciones de lectura y escritura de manera que no superpongan de modos indeseables.

Pero no podemos jugarnos a que el sistema operativo gestiona todo bellamente a favor de nuestros deseos.
Vamos a tener que tomar precauciones extra para que no haya conflicto alguno entre C y JavaScript.



Pero todos esos problemas no aparecerán por ahora.
Así que sólo ocupémonos de las tareas más básicas de lectura/escritura de datos en C.

Primero, definimos funciones WriteTextFile() y ReadTextFile(), que se encargan de escribir datos, y de leer datos, respectivamente, de archivos dados, en forma de texto plano. El comportamiento de las funciones será el siguiente:


int WriteTextFile(char* filename, char* sData);


La función espera que le pasemos como parámetros un nombre de archivo de tipo char* (una string) en la variable filename, y un trozo de texto plano en forma de cadena de caracteres en la variable sData de tipo char*.
El valor de retorno será un número entero n, que será EOF si hubo algún error de escritura, o bien un número no negativo si todo salió perfecto.
Este valor de retorno es el mismo que enviaría la función fputs() de la librería estándar stdio.h.

char* ReadTextFile(char* filename, char* buffer);

La función espera que le pasemos como parámetros un nombre de archivo de tipo char* (una string) en la variable filename, y una variable char* en la que se almacenarán los datos leídos del archivo.
Dicha variable tiene que tener espacio suficiente para albergar al menos MAXLONGSTR caracteres,
que es una constante que inicialmente definiremos como igual a 1023.
El valor de retorno de la función será esta misma cadena de caracteres leída del archivo.
Este valor de retorno es el mismo que enviaría la función fgets() de la librería estándar stdio.h.

Para que todo esto marche bien, es necesario invocar ciertas funciones de la librería stdio.h.
Así que ya vamos escribiendo este código:


#include <stdio.h>

#define MAXLONGSTR 1023

int WriteTextFile(char* filename, char* sData) {
    FILE* F;
    while ( !(F = fopen(filename, "w")) )
      ;
    // F != NULL, file 'filename' open for writing
    int n = fputs(sData, F);
    while ( fclose(F) == EOF)
      ;
    return n;
}

char* ReadTextFile(char* filename, char* buffer) {
    // size(buffer) >= MAXLONGSTR
    FILE* F;
    while ( ! (F = fopen(filename, "r")) )
      ;
    // F != NULL, file 'filename' open for reading 
    fgets(buffer, MAXLONGSTR, F);
    while (fclose(F) == EOF)
      ;   
    return buffer;
}


Como puede observarse, en ambas funciones hemos puesto un bucle while que, mientras la apertura del archivo filename para escritura ("w") o lectura ("r") da el resultado NULL (que significa error al intentar el archivo), no hace nada, y procede a repetir el intento de apertura del archivo.

Lo mismo hicimos para fclose(), aunque esta vez hay que comparar con EOF.

A continuación se usan directamente las funciones estándar fputs y fgets.
Se cierra el archivo, y por último se retorna el valor que hayamos colectado en las llamadas a fputs o fgets, respectivamente.



Nos interesa mantener los mismos nombres de archivo para las consolas de entrada y salida que hemos establecido ya en nuestro código JavaScript. Así que definimos estos nombres como constantes al principio de todo:


#define BROWCON_OUTPUT_FILENAME "browcon.output.txt"
#define BROWCON_INPUT_FILENAME  "browcon.input.txt"


Además, necesitamos definir variables en las que almacenaremos los nombres de nuestros archivos, así como el directorio base de todos ellos:

char browcon_base_dir[MAXLONGSTR] = "";
char browcon_output_file[MAXLONGSTR] = "";
char browcon_input_file[MAXLONGSTR] = "";


Inicialmente tienen un valor "cadena vacía", pero luego serán redefinidos a los valores deseados.
¿Cuándo y cómo?
Lo haremos con una función encargada de inicializar valores y variables, y que más tarde nos puede servir para dar arranque a algunas otras operaciones.

Vamos a necesitar la librería string.h de C.

He aquí el código:


#include <string.h>

void browcon_start(char* base_dir) {
    strcpy(browcon_base_dir, base_dir);   
    strcat(strcpy(browcon_output_file, base_dir), BROWCON_OUTPUT_FILENAME);   
    strcat(strcpy(browcon_input_file, base_dir), BROWCON_INPUT_FILENAME);
}


Como se ve, a fin de inicializar el directorio base de la browcon, en el lado de C, habrá que pasarle dicho directorio base en forma explícita como parámetro a la función browcon_start().

Obtener alegremente este directorio base, como hicimos en JavaScript, no es tan fácil, a menos que usemos librerías especializadas para ello.
Estudiaremos varias alternativas más adelante.
Por ahora, indicaremos este directorio en forma manual, poniéndolo directamente en el código C.



Ya estamos en condiciones de imitar a las funciones puts() y gets() de la librería estándar stdio.h de C.
Definiremos funciones browcon_puts() y browcon_gets() que harán tareas análogas, pero esta vez escribiendo y leyendo datos de los archivos browcon.output.txt y browcon.input.txt.


int browcon_puts(char* s) {
    return WriteTextFile(browcon_output_file, s);
}

char* browcon_gets(char* s) {
    return ReadTextFile(browcon_input_file, s);
}


La función browcon_puts() toma los caracteres del parámetro s y los envía al archivo browcon_output_file,
mientras que la función browcon_gets() toma los caracteres del archivo browcon_input_file, y los almacena en s,
que tiene que tener espacio suficiente para albergar los datos.



Las funciones ReadTextFile() y browcon_gets() leen solamente la primer línea de texto del archivo, ignorando el resto.
Esto tiene sentido porque la consola de entrada será siempre una simple línea de texto, y nada más.
No obstante, siempre hay tiempo de modificar este comportamiento, si alguna vez hiciera falta.

Sin embargo, cabe notar aquí que el nombre ReadTextFile para la función es engañoso, porque sólo podremos leer, por ahora, la primer línea de texto del archivo.



Vamos a necesitar variables en las que almacenar temporalmente los datos leídos o escritos de la browcon.
También puede que nos haga falta una variable en la cual almacenar el número entero devuelto por las llamadas a fgets().

Serán variables globales (por ahora), definidas como:


char browcon_output[MAXLONGSTR] = "";
char browcon_input[MAXLONGSTR] = "";
int  browcon_errn = 0;




Por fin, vamos a definir unas macros que emulen el comportamiento de las funciones printf y scanf.
Se llamarán browcon_printf() y browcon_scanf().

La macro browcon_printf() se puede usar exactamente de la misma manera que printf(), aceptando un número variable de argumentos de cualquier tipo, y cuyos tipos son interpretados con la típica cadena de formato que todos los programadores de C conocen de memoria.
Además, retorna un valor entero, con el mismo significado que el de printf() (más precisamente, que el de fputs()).

De modo análogo, la macro browcon_scanf() se puede usar del mismo modo que scanf(), también con número variable de argumentos, y mediante las mismas vicisitudes y reglas que usaríamos para dar valores a variables mediante una llamada a scanf().
Su valor de retorno es análogo al de scanf() (más precisamente, al de sscanf()).

¿Cómo logramos esa magia?

Lo hacemos con la ayuda de las funciones sprintf() y sscanf(), que se encargan de tomar una cadena de texto, y tratarla como si fuera la consola de entrada/salida de datos.
Las macros tienen, pues, una sencilla definición:


#define browcon_printf(fmt, ...) ( \
    sprintf(browcon_output, (char*)fmt, __VA_ARGS__),    \
    browcon_errn = browcon_puts(browcon_output) \
    )


#define browcon_scanf(fmt, ...) \
    (browcon_errn = sscanf(browcon_gets(browcon_input), fmt, __VA_ARGS__))
 


La última macro está muy compacta, y tiene unos trucos extraños en C.
La función sscanf() requiere que su primer argumento sea un buffer en donde almacenar caracteres.
¿Le hemos pasado eso como primer parámetro?
De hecho, sí, porque la función browcon_gets() devuelve un puntero al primer caracter de una cadena de caracteres, y ése sería el buffer que vamos a utilizar.
Más aún, la dirección de memoria de ese puntero coincide con la de browcon_input.
Apuntan a la misma cadena.



Pongamos todo esto más o menos en orden.
Obtendremos nuestra primer librería en C para manejar nuestra browcon.
La llamaremos browcon00.31.h, aludiendo a la versión 00.31 de nuestro proyecto.

Lo ponemos en Spoiler:

(browcon00.31.h)


// Browcon 00.31
// 2013/May/12

#include <stdio.h>
#include <string.h>

#define MAXLONGSTR 1023

#define BROWCON_OUTPUT_FILENAME "browcon.output.txt"
#define BROWCON_INPUT_FILENAME  "browcon.input.txt"

char browcon_output[MAXLONGSTR] = "";
char browcon_input[MAXLONGSTR] = "";
int  browcon_errn = 0;

int WriteTextFile(char* filename, char* sData) {
    FILE* F;
    while ( !(F = fopen(filename, "w")) )
      ;
    // F != NULL, file 'filename' open for writing
    int n = fputs(sData, F);
    while ( fclose(F) == EOF)
      ;
   
    return n;
}

char* ReadTextFile(char* filename, char* buffer) {
    // size(buffer) >= MAXLONGSTR
    FILE* F;
    while ( ! (F = fopen(filename, "r")) )
      ;
    // F != NULL, file 'filename' open for reading 
    fgets(buffer, MAXLONGSTR, F);
    while ( fclose(F) == EOF)
      ;
   
    return buffer;
}

char browcon_base_dir[MAXLONGSTR] = "";
char browcon_output_file[MAXLONGSTR] = "";
char browcon_input_file[MAXLONGSTR] = "";

int browcon_puts(char* s) {
    return WriteTextFile(browcon_output_file, s);
}

char* browcon_gets(char* s) {
    return ReadTextFile(browcon_input_file, s);
}


void browcon_start(char* base_dir) {
    strcpy(browcon_base_dir, base_dir);   
    strcat(strcpy(browcon_output_file, base_dir), BROWCON_OUTPUT_FILENAME);   
    strcat(strcpy(browcon_input_file, base_dir), BROWCON_INPUT_FILENAME);
}

#define browcon_printf(fmt, ...) ( \
    sprintf(browcon_output, (char*)fmt, __VA_ARGS__),    \
    browcon_errn = browcon_puts(browcon_output) \
    )


#define browcon_scanf(fmt, ...) \
    (browcon_errn = sscanf(browcon_gets(browcon_input), fmt, __VA_ARGS__))
   


[cerrar]



El archivo browcon00.31.html será idéntico, por ahora, a la versión 00.30, a fin de no confundir al auditorio.
Igual lo incluimos aquí:

browcon00.31.html



Pero esta historia aún no acaba.
Tenemos que poner a prueba nuestra librería.
Lo haremos con un programa de prueba, llamado testbc01.c,
que intentará enviar y recibir datos desde los archivos de la browcon.


 
#include <stdio.h>
#include "browcon00.31.h"

int main(void) {
   
    printf("Estableciendo ruta y archivos...\nPresione Enter para continuar en cada paso.\n\n");

    browcon_start("C:\\programming\\C\\browcon\\");   
    getchar();   
   
    printf("Enviando...\n");         
    browcon_printf("Enviando una cadena de texto común y corriente.", "");   
    getchar();
   
    printf(" Ahora...\n");   
    browcon_printf(" 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();
    browcon_scanf("%i %i %s %i", &a, &b, s, &c);   

    printf("Datos leídos: %i %i %s %i\n", a, b, s, c);   
    getchar();
}



Lo que hace nuestro programa es inicializar el directorio base y los archivos de la browcon, para entrada y salida.
Luego espera a que presionemos Enter para comenzar.
A continuación envía una cadena de texto.
Otra vez hay que presionar Enter.
Sigue otra cadena de texto, pero esta vez formateada para enviar datos de diversos tipos.
Presionar Enter.
Luego se definen unas variables en las que se alojarán valores, al leer datos desde la browcon.
Presionar Enter.
Se muestran los datos leídos.

Para que este experimento funcione, tenemos que poner mucho de nuestra parte, llevando un control manual de todas las operaciones.
Hagamos esto:

1. Abrir el archivo browcon00.31.html con Internet Explorer.
2. A cada pregunta de autorización que pida el navegador, decir que sí.
3. Compilar y correr el programa testbc01.c.
4. Presionar Enter.
5. En la consola estándar de C, se mostrará un mensaje que indica que la primer cadena se ha enviado.
6. Ir entonces al navegador, y clickear en "Send data...", lo cual simulará el envío de datos de C a JavaScript.
7. Los datos de esa cadena de caracteres aparecerán en la browcon (en el navegador).
8. Volver a la consola de C, y presionar Enter para que el programa continúe.
9. Aparecerá la cabecera del segundo envío de datos a la browcon.
10. Ir de nuevo al navegador, y hacer click otra vez en "Send data...".
11. El 2do envío de datos aparecerá ahora en el navegador.
12. Volver a la consola estándar de C, y presionar Enter para continuar.
13. Aparecerá el mensaje indicando que se hará una petición de datos a la browcon.
14. Aprovechar para ir al navegador, y efectuar esta petición de datos manualmente, clickeando el botón "Get data...".
15. Aparecerá el casillero para entrar datos.
16. Aquí hay que ser muy cuidadosos, porque el programa en C espera que le enviemos exactamente 4 datos, separados por espacios: el 1er dato es un número entero, el 2do dato otro número entero, el 3er dato es una palabra, y el 4to dato otro número entero. Entrar datos cualesquiera, respetando estas especificaciones.
17. Presionar Enter (en el navegador). Aparecerá el eco de los datos ingresados.
18. Volver a la consola de C, y presionar Enter para continuar.
19. El programa leerá los datos de la consola de entrada de la browcon.
20. Luego mostrará, en la consola estándar, los datos leídos.
21. Presionar Enter de nuevo para terminar.

Realizando estos pasos, podremos verificar si todo funciona bien.
Yo seguí esos pasos, y obtuve respectivamente, en el navegador, y en la consola estándar de C, lo que muestro en la foto:


12 Mayo, 2013, 07:04 am
Respuesta #12

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.32) Una pequeña mentira

En el mensaje anterior les dije una pequeña mentira.

El uso de browcon_printf() y browcon_scanf() no es "exactamente" el mismo que printf() y scanf().

Cuando printf() o scanf() toman un solo parámetro, es decir, el primero, que es la cadena de formato, el programa compila sin problemas.

Pero no sucede lo mismo con browcon_printf() y browcon_scanf().
Estas macros necesiten al menos un segundo parámetro.
Es por eso que en el programa testbc01.c, les puse como 2do parámetro una cadena en blanco: "".

Este es el precio que tendríamos que pagar a cambio de poder definir ambas macros de la manera sencilla y escueta en que lo hicimos.

El estándar C99 no permite quitar este parámetro extra en las macros con número variable de parámetros.

De paso, expliquemos un poco cómo es que las macros funcionan internamente.
Hemos usado el poder de las macros con número variable de parámetros, que le dan mucha potencia al lenguaje C,
permitiendo extenderlo del modo en que nosotros lo acabamos de hacer, redefiniendo funciones de la biblioteca estándar stdio.h.
En la cabecera de la macro, se indica con puntos suspensivos que allí se espera un número variable de argumentos.
Y luego, para poder referirnos a esa lista de argumentos, debemos usar el identificador __VA_ARGS__,
que instruye al preprocesador para que en ese lugar reemplace por la lista de argumentos pasados como parámetro a la macro.

Cuando se invocan este tipo de macros, hace falta que en __VA_ARGS__ "haya algo", no puede ser una lista vacía.
Y esto obliga a que exista al menos un parámetro.

¿Se puede remediar esto?
La verdad es que sí se puede, siempre y cuando no necesitemos realizar ninguna operación especial sobre la cadena de formato.
Tendremos que tener esto en cuenta para el futuro, y dar rodeos en caso de que algo nos obligue a operar con la cadena de formato.

La solución consiste en definir las macros sin argumentos explícitos, poniendo solamente puntos suspensivos.

El resultado será algo como esto:



#define browcon_printf(...) ( \
    sprintf(browcon_output, __VA_ARGS__),    \
    browcon_errn = browcon_puts(browcon_output) \
    )


#define browcon_scanf(...) \
    (browcon_errn = sscanf(browcon_gets(browcon_input), __VA_ARGS__))
   


Con este cambio, podemos ahora sí considerar a browcon_printf() y browcon_scanf() como análogas a las conocidas printf() y scanf().

Llamaremos versión 00.32 a la obtenida con esta pequeña modificación.


12 Mayo, 2013, 07:59 pm
Respuesta #13

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(00.33) Ocultación de la interfase de C

Ahora 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!
 ;D

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__))
   


[cerrar]



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!

 ;D

'Ta lindo...

14 Mayo, 2013, 10:35 am
Respuesta #14

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Coordinación y comunicación entre procesos independientes

Aquí analizaremos el punto más delicado del proyecto browcon.
Tenemos dos procesos, uno en C y otro en JavaScript, que deben comunicarse entre sí, y tienen que estar coordinados.

En general la mecánica es que el programador, desde C, envía una sentencia bcprintf() o bcscanf(), y JavaScript recibe la orden y la procesa.
Para que esto funcione, C tiene que enviar varias informaciones a JavaScript: el tipo de operación solicitada (si es de escritura bcprintf() o de lectura bcscanf()), los datos a procesar (sólo en el caso de bcprintf(), que envía texto a imprimir en la browcon), y una señal de que todos los datos están correctamente preparados.
Esta "señal" es lo último que C tiene que enviar, porque si C envía la "señal" a JavaScript antes de tener los demás datos listos... es que no están listos aún, y la información que procesará JavaScript será, por supuesto, incompleta o errónea.

Cuando JavaScript recibe la "señal" de que debe actuar, puede comenzar a procesar los datos e interpretar la orden recibida, actuando de uno u otro modo en el navegador.

Mientras esto ocurre, el programa en C tiene que interrumpir su flujo normal de proceso, a la espera de que JavaScript termine de actuar, porque si no, si C continuara sin freno alguno, podría producir enseguida una nueva orden de lectura o escritura, que se sobrepondría a la anterior, confundiendo a JavaScript.
El resultado de esto, es que habría órdenes que quedarían sin procesar, o que se mezclarían.

Para que ninguna orden de lectura/escritura se pierda en el camino, C y JavaScript tienen que avisarse mutuamente de lo que van haciendo, y esperarse el uno al otro, como en una danza de procesos, a fin de ir coordinados.
Mientras uno de ellos realizar una tarea, el otro espera, y viceversa.

______________

Supongamos que nos interesa una orden de escritura, bcprintf().
En C ponemos bcprintf("Hola mundo"); , que escribe la orden "bcprintf()" en browcon.crequest.txt y "Hola mundo" en el archivo browcon.output.txt, y luego pone una señal de que todo está listo escribiendo un "1" en browcon.flagc.txt.

Aquí el C espera una respuesta de JavaScript, una señal de que ya ha terminado de escribir "Hola mundo" en el navegador.
Es JavaScript quien debe ahora generar una señal informando esto.

Nótese que no queda más remedio que informar mediante estas señales, porque ni C puede adivinar lo que ocurre en el navegador, ni JavaScript puede adivinar lo que ocurre en el flujo de ejecución de datos del programa en C.

Ahora JavaScript ingresa, cada 500 milisegundos, en el proceso RefreshConsole().
Ahí verifica si en los últimos 500 milisegundos se ha generado una señal "1" en el archivo browcon.flagc.txt.
Cuando la encontró, lee el archivo browcon.crequest.c para ver qué diablos quiere C.
Dado que ahí verá una orden "bcprintf", buscará datos leyendo el archivo browcon.output.txt.
Encuentra entonces el texto "Hola mundo", y lo imprime en el bloque divprintf en la ventana del navegador.
Ahí terminó de procesar la orden.
Entonces JavaScript envía una señal, poniendo "1" en browcon.flagj.txt, de que JavaScript está listo para recibir y procesar una nueva orden.

Mientras tanto C estaba a la espera. ¿De qué?
Bueno, C tiene que ir leyendo el archivo browcon.flagj.txt, y verificar que allí hay o no hay un "1".
Cuando lo encuentra, quiere decir que ya puede continuar con el flujo del programa, y quizás enviar a JavaScript una nueva orden de lectura/escritura.

____________________

Pareciera que esto tiene que funcionar, pero hay algunos inconvenientes en la lógica, que tienen que ver con los valores mismos de "flag" que usamos.
Veamos la situación con más detenimiento.

Tanto el "flagc" como el "flagj" pueden valer "0" ó "1", para indicar "aún no estoy listo" y "ya estoy listo", respectivamente.
Hemos dejado claro cuándo estos flags tienen que valer "1".
Pero, ¿cuál es el momento correcto para ponerlos a "0" otra vez?

Si dejáramos que valgan "1", sin cuidado, entonces, o bien JavaScript repetirá la misma orden varias veces, o bien C seguirá adelante sin freno alguno, sobreescribiendo órdenes, que JavaScript no tendría tiempo de procesar.

Además, los flags tienen que tener algún valor inicial. ¿Cuál conviene?

Bereshit ("En el principio...", Génesis 1.1) necesitamos que JavaScript esté listo para recibir órdenes, pero también queremos que JavaScript no haga nada hasta que C explícitamente diga que tiene una orden lista.

Así que el valor inicial de los flags debe ser:

flagc == "0"
flagj == "1"

Notará el lector cómo es que a estas alturas ya no me importa nada, y estoy tratando a los archivos como "variables".
Son como "variables" que pueden compartir los dos procesos C y JavaScript. Si no, ¿de qué otro modo puede compartir información?

Ahora C envía una orden bcprintf() y espera, mientras que JavaScript hace lo suyo.

¿Cómo es la espera de C? Tiene que preguntar, con una condición en un while, si JavaScript está listo o no lo está.
Mientras JavaScript "no está listo", C tiene que seguir esperando.
La sentencia sería "más o menos" así:

while (flagj == "0")
   ; // nada...

Sólo cuando JavaScript avise poniendo flagj = "1", allí C continúa.
Pero esto no funciona, porque flagj ya valía "1" en un principio, y así C continuará sin freno con el flujo del programa.

Así que, cuando JavaScript recibe la señal flagc == "1", indicando que debe procesar una nueva orden,
inmediatamente (rapidísimo), tiene que poner flagj = "0", para indicar que por un rato no estará disponible para nuevas órdenes, y que C debe esperar.
Ahora sí, al terminar su tarea, JavaScript enviará una señal poniendo flagj = "1".

El esquema sería así:

(1) JavaScript inicializa flagj = "1" e inicia el temporizador que busca órdenes de C cada 500 milisegundos.
(2) C inicializa flagc = "0"
(3) C elabora una orden bcprintf()
(4) C envía la señal flagc = "1" y se pone en espera de que flagj sea "1" de nuevo
(5) JavaScript detecta la señal y pone flagj = "0"
(6) JavaScript procesa la orden
(7) JavaScript envía la señal flagj = "1" indicando que terminó
(8) C detecta la señal flagj == "1" y continúa

A propósito escribí el esquema de pasos, para poner en evidencia que hay un obstáculo lógico entre los pasos (4) y (5).
Observemos que C tiene que enviar la señal primero, y que sólo después de esto JavaScript puede detectarla y cambiar en consecuencia el valor de flagj a "0".
Después de esto es que C tendría que ponerse en espera, preguntando si aún flagj == "0"...

Pero no hay manera de controlar el orden en que se hacen estas operaciones.
Luego de que C envía la señal flagc = "1", no hay manera de decirle que espere a JavaScript hasta que JavaScript detecte la señal, y tenga tiempo de ponera flagj = "0".
En ese breve lapso de tiempo, C tiene oportunidad de verificar si flagj == "0", y le dará falso, porque aún flagj no ha podido cambiarse a "0", sino que viene valiendo "1" desde "antes".

Sólo la suerte puede ayudarnos aquí, rezando para que el controlador de multitarea del sistema operativo elija darle prioridad al proceso de JavaScript, postergando al de C lo bastante como para que la primera vez que C pregunte en su bucle while por el valor de flagj, "vea" un valor "0".
Ciertamente, no podemos confiarnos a las oraciones, y tendremos que remediarlo con lógica de programación.

Aquí la idea es imitar un poco el proceso de comunicación por radio, en el que la gente se avisa si ha recibido o no el último mensaje.
Esto es como un "eco" del mensaje, cuando los radiohablantes dicen "copiado" o "recibido", y luego dicen "cambio", para dar lugar a que el otro hable.

Vamos a agregar nuevos flags, que sirvan para dar estos avisos en la comunicación.
En el archivo browcon.flagc.echoj.txt, el proceso JavaScript informará el "eco" de la señal recibida por parte de C,
y en browcon.flagj.echoc.txt, el proceso C informará el "eco" de la señal recibida por parte de JavaScript.
Brevemente diré flagc.echoj y flagj.echoc.

Lo bueno de estas nuevas "variables" o "flags", es que pueden inicializarse con valores distintos, y puede preguntarse por sus valores en momentos independientes a los de flagc y flagj.

Dado que, en el momento en que C envía la señal flagc = "1", nos interesa que C quede inmediatamente frenado,
necesitamos que C esté informado de que JavaScript aún no ha recibido la señal, y por lo tanto el eco de la misma tiene que ser inicialmente "0".
Así, ponemos flagc.echoj = "0" al inicio del proceso JavaScript.

Ahora JavaScript puede tomarse las cosas más relajadamente, porque sabe que C no hará nada hasta recibir el eco de la señal.
Una vez que JavaScript recibe la señal flagc = "1",
cambia el valor de flagj a "0", y sólo después, con total tranquilidad, envía el eco flagc.echoj = "1".
O sea, el envío del echo no tiene por qué ser inmediato.
Más bien tiene que ser "oportuno".

Ahora, cuando C reciba el eco de la señal, recién ahora es que comenzará a preguntar si flagj == "0".
En este momento, por el orden en que hemos hecho las cosas, C encontrará que flagj == "0" en las primeras iteraciones del bucle while.
Hemos conseguido coordinar ambos procesos satisfactoriamente.

Mas, ahora, se nos presenta el problema de que necesitamos que flagc.echoj valga de nuevo "0" antes de la siguiente llamada a bcprintf o bcscanf.
¿Cómo logramos que JavaScript cambie este valor en el momento menos inoportuno?

Bueno, tengamos en cuenta que ya el valor de flagc ha sido utilizado, y no necesitamos que siga valiendo "1".
De hecho, sería una buena oportunidad ponerlo a "0" una vez que JavaScript ya ha enviado el eco de la señal.
Así que ponemos flagc = "0".

Podríamos hacer que JavaScript espere todavía un poco más en este momento a C, a que cambie el valor del flag, y sólo después de esta breve espera es que procesaría, por fin, la orden bcprintf.
Esto funcionaría como un "eco del eco". ¡Por Dios!
Y es en este punto, en que el valor de flagc.echoj ya ha sido usado, y que C está detenido esperando a que flagj == "1", que tenemos tiempo, en JavaScript, de poner flagc.echoj = "0".

Veamos, entonces, el esquema de las operaciones.
En lo que sigue, voy a usar la abreviatura "J" para referirme a JavaScript.

(0) J inicializa flagj = "1", flagc.echoj = "0"
(1) J espera a que flagc == "1"
(2) C inicializa flagc = "0"
(3) C prepara una orden bcprintf
(4) C envía la señal flagc = "1"
(5) C espera a que flagc.echoj == "1"
(6) J detecta la señal flagc == "1"
(7) J cambia su estado a flagj = "0"
(8) J envía el eco de la señal flagc.echoj = "1"
(9) J espera el eco del eco, indicado con flagc == "0"
(10) C detecta el eco flagc.echoj == "1"
(11) C cambia el valor flagc = "0" (que sirve como eco del eco)
(12) C espera a que flagj == "1"
(13) J detecta el eco del eco flagc == "0"
(14) J procesa la petición bcprintf
(15) J envía la señal flagj = "1"

Bueno, esta historia no ha terminado.
Ahora que JavaScript es quien ha enviado su señal de "1", la recepción e intercambio de ecos con C tiene que repetirse como en los pasos (4) a (13), o al menos con las mismas precauciones, aunque ahora intercambiando los papeles.
Una vez que ambos procesos hayan coordinado bien sus pasos, podrán continuar cada uno por su lado, sin mayores novedades.

Lo importante es que, antes de terminar todas las operaciones, los estados de los flags tienen que volver a sus valores originales, para que todos los pasos funcionen correctamente en la próxima sentencia bcprintf o bcscanf.

Necesitamos, pues, un nuevo flag, que servirá para que C envíe sus ecos a JavaScript.
Será el archivo browcon.flacj.echoc.txt, que brevemente escribiré como flagj.echoc.

Veamos cómo sigue la historia:

(16) J reinicia flagc.flagj = "0"
(17) J espera a que flagj.echoc == "1"
(18) C detecta la señal flagj == "1"
(19) C envía el eco de la señal flagj.echoc = "1"
(20) C continúa con el flujo del programa (ya no le importa más nada de JavaScript)
(21) J detecta el eco flagj.echoc == "1"
(22) J continúa por su lado (ya no le importa más nada de C)

Aquí se nos presentan dos problemas adicionales.
Tenemos que inicializar adecuadamente el valor de flag.echoc, que lógicamente, tiene que ser "0" para que tenga sentido el paso (17). Así que modificamos el paso (2) así:

(2) C inicializa flagc = "0", flagj.echoc = "0"

Pero también tenemos que devolver el estado flagj.echo = "0" en algún momento entre los pasos (3) a (23).
¿Cuándo es esto oportuno?
Bueno, la respuesta es sencilla: en el mismo paso (2), sin más.

Lo que tenemos que tener en cuenta aquí es que los pasos (1) a (22) se repetirán siempre, en cada sentencia bcprintf o bcscanf.
Sólo el paso (0) es el que se ejecuta por primera y única vez, y depende de JavaScript, no de C.
Esto asegura que, en el paso (17), cuando JavaScript pregunte si flagj.echoc == "0" ó "1", el valor de ese flag estará correctamente inicializado a "0" previamente a ese momento.

Con esto, me parece a mí que la lógica del algoritmo bi-proceso funcionará correctamente.

En el próximo post vamos a implementar este algoritmo, y ver si realmente funciona, o si aparecen nuevas dificultades.


14 Mayo, 2013, 06:53 pm
Respuesta #15

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Coordinación y comunicación entre procesos independientes (contiinuación)

Siguiendo la filosofía del post anterior, diseñemos ahora un algoritmo bi-proceso para manejar las órdenes bcscanf.

(0) J inicializa flagj = "1", flagc.echoj = "0"
(1) J espera a que flagc == "1"
(2) C inicializa flagc = "0"
(3) C prepara una orden bcscanf
(4) C envía la señal flagc = "1"
(5) C espera a que flagc.echoj == "1"
(6) J detecta la señal flagc == "1"
(7) J cambia su estado a flagj = "0"
(8) J envía el eco de la señal flagc.echoj = "1"
(9) J espera el eco del eco, indicado con flagc == "0"
(10) C detecta el eco flagc.echoj == "1"
(11) C cambia el valor flagc = "0" (que sirve como eco del eco)
(12) C espera a que flagj == "1"
(13) J detecta el eco del eco flagc == "0"
(14a) J procesa la petición bcscanf, haciendo visible el casillero de entrada de datos del formulario
(14b) J espera a que el usuario introduzca datos y los envíe a través del formulario
(14c) El usuario ingresa datos en el casillero de entrada y presiona Enter
(14d) J dispara la función senddata() de proceso del formulario
(14e) J envía el texto del formulario a browcon.input.txt
(14f) J envía el eco del texto del formulario a divprintf
(15) J envía la señal flagj = "1"
(16) J reinicia flagc.flagj = "0"
(17) J espera a que flagj.echoc == "1"
(18) C detecta la señal flagj == "1"
(18*) C busca datos en browcon.input.txt, los lee y procesa
(19) C envía el eco de la señal flagj.echoc = "1"
(20) C continúa con el flujo del programa (ya no le importa más nada de JavaScript)
(21) J detecta el eco flagj.echoc == "1"
(22) J continúa por su lado (ya no le importa más nada de C)

Notemos que, en este caso, hemos tenido que desarrollar en más detalle el paso (14), a fin de procesar correctamente la orden bcscanf.

En el paso (18*) tengo la duda de si conviene ponerlo ahí, o como paso (19*).
Al ponerlo entre (18) y (19) lo que ocurre es que se posterga el envío del eco desde C a JavaScript.
Eso sería como mentirle un poco a JavaScript, imponiendo una demora, para darnos tiempo en C a leer los datos de browcon.input.txt y procesarlos.
Pero podemos interpretar que el eco, en este caso, significa no sólo un "eco del flag", sino un "eco de toda la operación input".

Al poner la lectura de browcon.input.txt después de (19), sólo estaría enviando un eco de la señal.
Esto podría dar lugar a algún tipo de descoordinación entre los procesos... o no.
Veamos. Una vez que C envía este eco, se desentiende de JavaScript, y sigue su curso, hasta que una nueva sentencia bcprintf o bcscanf aparece.
En cambio JavaScript queda esperando hasta recibir este eco, y después recién se "libera", desentendiéndose de C.

Si ponemos la lectura de datos en (18*), como hicimos, las operaciones de envío del eco desde C, y de recepción de este mismo eco desde JavaScript, suceden en instantes de tiempo más cercanas, casi en simultáneo, y creo yo que es más conveniente lograr esta coordinación.
(Sobretodo, porque en futuras versiones el algoritmo puede llegar a agregar nuevas complicaciones, y mejor tener desde un principio una base sólida).



14 Mayo, 2013, 09:00 pm
Respuesta #16

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Manejos del temporizador en JavaScript

Antes de proseguir, es importante analizar el temporizador en JavaScript.

La experiencia me ha indicado que no puedo usar bucles while en JavaScript a fin de "esperar" a que por ejemplo C envíe una señal, cambiando el contenido de un archivo.
Lo que me ha ocurrido es que JavaScript "no suelta" el procesador hasta que el ciclo while haya terminado.
Entonces no da tiempo a que C haga una porción de sus tareas.

En cambio, haciendo que JavaScript actúe cada 500 milisegundos, en el entretiempo el sistema operativo cede una ventana temporal para que C ejecute instrucciones.

De hecho, el problema que tenemos es más profundo, porque no sabemos a ciencia cierta (al menos yo no sé), cómo funciona la gestión de procesos en un sistema operativa multitarea, como es el caso de Windows.
Tenemos dos procesos, uno en C y otro en JavaScript, que corren "al mismo tiempo", pero en realidad lo que ocurre es que Windows va cediendo en forma organizada y más o menos equidistribuida, ventanas de tiempo para que cada proceso siga su curso en forma independiente.

Esto no nos asegura, entonces, que el C no adolezca del mismo problema con los ciclos while que hallamos en JavaScript.
Yo estoy suponiendo que estos problemas no se dan en la práctica...
Pero una manera más segura de desarrollar estos algoritmos biproceso sería, en mi opinión, evitar los bucles while que hemos colocado en las librerías, y tratar de usar también en C un "temporizador", tal como en JavaScript.



En fin, por ahora sólo nos interesa JavaScript.

El método setInterval() se usa, como hemos visto, para ejecutar una tarea cada un cierto intervalo fijo de tiempo.
Este intervalo de tiempo por ahora lo vamos a ajustar manualmente.
Quizás más adelante podamos investigar un ajuste automatizado y más fino. Será interesante...

El método setInterval tiene este formato de llamada:

setInterval(func(), ms);

en donde func() es una función o método JavaScript, y ms es un número que indica la cantidad de milisegundos de espera entre cada llamada a func().
Si ponemos

setInterval(RefreshConsole(), 500);

lograremos que JavaScript ejecute la función RefereshConsole() cada 500 milisegundos.



Una función importante es clearInterval(), que tiene la gran virtud de parar el molesto ciclo repetitivo.

El modo de uso es el siguiente:

Cuando se invoca el método setInterval(), a uno de los objetos de HTML (en nuestro caso, directamente a toda la ventana),
el resultado de la operación es un objeto quien es el encargado de quedar activo repitiendo la acción indicada cada ms milisegundos.
Ese objeto tendremos que cargarlo en una variable de JavaScript.
Cuando queramos suspender las repeticiones, llamamos al método clearInterval() de este último objeto.

Una vez cumplidas ciertas tareas, se puede volver a cargar el temporizador con setInterval(), si hiciera falta.

Así, es conveniente trabajar siempre con el par setInterval(), clearInterval(), en la medida de lo posible.
Un ejemplo:


tempobj = window.setInterval(RefreshConsole(), 500);

tareas varias
tareas varias
tareas varias

window.clearInterval(tempobj);

tempobj = window.setInterval(post("Hola Bart. <br />"), 1500);


Ahora tendríamos que separar las diversas tareas de (0) a (22), que corresponden a JavaScript, y planificar los procesos adecuadamente.

El paso (0) es de inicialización, y se debe hacer en el momento de carga de la página.

El paso (1), de "espera" de JavaScript, se realizaría con el temporizador.
De hecho, las únicas tareas asociadas al temporizador serán las de "espera", pues son las que reemplazan a las sentencias while, que no podemos utilizar...

Al mismo tiempo, hay que crear un objeto asociado al temporizador, y hacemos entonces esto:

temp1 = window.setInterval(Waiting1(), 500);

La función Waiting1() verificará si flagc sea igual a "1" o "0".

Una vez que flagc == "1", (paso (6)), en ella misma hacemos las siguientes acciones:

* Paramos el objeto temp1 mediante una llamada a window.clearInterval(temp1).
* Ponemos flagj = "0" (paso (7)).
* Ponemos flagc.echoj = "1" (paso (8)).
* Activamos una nueva espera, mediante:

temp2 = window.setInterval(Waiting2(), 500);

La función Waiting2() verifica cada 500 milisegundos si flagc == "0" (paso (9)).
Una vez que encuentra que flagc == "0", realiza estos pasos:

* Parar el temporizador temp2 mediante: window.clearInterval(temp2) (paso (13)).
* Verificar si la orden enviada por C es bcprintf o bcscanf.
* En caso de que la orden sea bcprintf, hace la llamada a post(), y luego continúa con el paso (15).

* En caso de que la orden sea bcscanf, activar el casillero de entrada de datos (divscanf.visibility = "visible") (paso (14a)).
*** Ahora la browcon no haría nada, ni siquiera verificar el temporizador cada 500 milisegundos. Sólo reaccionará cuando el usuario envíe una cadena de texto por el formulario.
*** Cuando esto ocurra, se abre senddata() (paso 14(d)).
*** Tras terminar todas las acciones (envío de datos a browcon.input.txt, paso (14e), y eco de datos hacia divprintf, paso (14f)), se continúa con el paso (15).

* El paso (15) se implementa con el paso de control a una función, que llamaremos middle_step(). No es muy explicativa, pero se encarga de poner flagj = "1", flagc.echoj = "0", y lanzar una nueva espera.
* Se lanza esta nueva espera mediante

temp3 = window.setInterval(Waiting3(), 500);

La función Waiting3() verificará cada 500 milisegundos si flagj.echoc == "1".

Una vez que esto ocurre, Waiting3() realiza estos pasos:

* Parar el temporizador temp3 mediante window.clearInterval(temp3).
* Iniciar un nueva espera mediante

temp4 = window.setInterval(Waiting4(), 500);

Esta vez, la función Waiting4() verifica (paso 21) si flagj.echoc == "1".
Una vez que esto ocurre, realiza estos pasos:

* Para el temporizador temp4 mediante window.clearInterval(temp4).
* Reinicia el ciclo de tareas desde el principio (o sea, yendo al paso (1), no al (0)), otra vez haciendo:

temp1 = window.setInterval(Waiting1(), 500);



En el momento en que esta llamada a setInterval() ocurre, en que se activa de nuevo Waiting1() cada 500 milisegundos, y asignado a la misma variable temp1 que al principio, nos encontramos conque el "estado" de los flags de JavaScript es el mismo que tenían al principio del programa.
Es como si todo hubiera comenzado desde cero otra vez.

Es decir, tenemos que asegurarnos que la lógica del algoritmo nos deja en el paso (22) siempre el siguiente estado de cosas:

flagj = "1", flagc.echoj = "0".
flagc = "0", flagj.echoc = "0"

Los flags que controla C, no podemos controlarlos completamente desde JavaScript.
Desde JavaScript tenemos que confiar que la contraparte de C está actuando con una lógica compartida, obedeciendo un algoritmo bi-proceso, en que C hace su parte.
Si se respetan los pasos (1) a (22), como antes, los flags controlados por C estarán de nuevo a "0" en el paso (22),
y entonces verdaderamente estaremos tal como al principio de todo.



Notemos también que ya hemos eliminado nuestra función RefreshConsole() en todo esto.
Habrá desaparecido, y ha sido reemplazada por sucesivos temporizadores, que a su vez están encadenados unos a otros:

temp1 = window.setInterval(Waiting1(), 500); // Al finalizar la espera,


Waiting2() {
   if (fin-de-la-espera)  {
        // tareas varias   

     temp3 = window.setInterval(Waiting3(), 500);
   }

}



Waiting3() {
   if (fin-de-la-espera)  {
        // tareas varias   

     temp4 = window.setInterval(Waiting4(), 500);
   }

}


Waiting4() {
   if (fin-de-la-espera)  {
        // tareas varias   

     temp1 = window.setInterval(Waiting1(), 500);
   }

}


Con esto, se genera un ciclo de llamadas Waiting1(), Waiting2(), Waiting3(), Waiting4(), y de nuevo Waiting1(), recomenzando el ciclo.



En cierto modo, lo que hemos hecho, es manejar el tránsito de dos calles que se cruzan, poniendo algo así como semáforos, o inspectores de tránsito.

Notemos que hay un momento, cuando se procesa una petición bcscanf, en que JavaScript no hace nada, ni siquiera una mísera verificación cada 500 milisegundos.
Estamos a merced del usuario, y su deseo o no de ingresar datos en el casillero de texto del formulario.

Si el usuario cierra el navegador, o si cancela la ejecución del programa en C, no hay algoritmo que valga.
No soy Dios para poder controlarlo todo.

De cualquier manera, hay buenas razones por las cuales el usuario pueda desear cerrar el navegador.
Por ejemplo, porque ha habido algún bloqueo de memoria, o porque algo no ha funcionado como esperaba, y desea reiniciar el programa.

Ocurre que es posible reiniciar fácilmente el programa en C, pero al hacer esto no se reinician automáticamente los flags de JavaScript, ni mucho menos lograremos que JavaScript se ponga en su "estado inicial".

Cuando queramos reiniciar la ejecución del programa en C, acompañado de un reinicio en el navegador, tendremos que hacer ambas cosas manualmente, siguiendo estos pasos:

* Cerrar el programa en C.
* Recargar la página con el botón de recarga del navegador.
* Volver a correr el programa en C.

Eso arreglará todo.

Inclusive, podemos agregar botones en nuestra browcon que explícitamente la reinicien a su estado inicial.



Otra observación que me gustaría hacer respecto el algoritmo explicado en estos últimos 3 posts, es que , si bien hemos necesitado usar varios flags para una sincronización efectiva y sin errores entre C y JavaScript, también ocurre que hemos podido solucionar la cuestión usando sólo 2 flags por cada una de ellos (2 para C y 2 para JavaScript).

Es importante tener en cuenta que los flags no tienen que multiplicarse indefinidamente, y que debemos lograr nuestros objetivos de efectividad y buena sincronización, usando la mínima cantidad posible de flags.
Hemos también combinado estos flags con 2 posibles acciones de muy distinta naturaleza: bcprintf y bcscanf.

Estos cuidados son importantes. Por un lado, hay pasos del algoritmo que son los mismos para ambos tipos de tareas, mientras que otros (como el 14 o el 18), no lo son.
Sin embargo, hemos procurado que el trabajo con los flags sea prácticamente el mismo en ambos casos, logrando así separar las tareas propiamente dichas de lectura/escritura, de las tareas de sincronización entre procesos.

Hemos respetado también el requisito de que C y JavaScript no puedan escribir sobre los mismos archivos, jamás, aunque sí puede que quieran acceder ambos a la vez a un mismo archivo, aunque mediante otras posibilidades (ambos leen, o uno escribe y el otro lee).
Esto lo logramos mediante el uso de "ecos de los flags". Su función es esa: la de evitar que C y JavaScript intenten escribir en el mismo archivo, al mismo tiempo.

En el próximo post pondremos el código propiamente dicho del algoritmo que hemos bosquejado hasta aquí.