Autor Tema: (C) Máximo Común Divisor - Algoritmo de Euclides

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

18 Agosto, 2013, 07:36 am
Respuesta #10

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Poniendo la interface en una librería...

Así como pusimos el algoritmo principal en una librería separada,
lo propio podemos hacer con la interface que interactúa con el usuario.

Vamos a definir una librería de nombre bui.h (Basic User Interface).
Esto quiere decir que nuestra librería no es muy ambiciosa.
Sin embargo intentará sistematizar en forma sólida algunas operaciones típicas de intercambio de datos con el usuario, a través de teclado y pantalla.



En un programa hay distintos tipos de informaciones o mensajes que se muestran al usuario.
Los pondremos todos juntos en una estructura que los coleccionará.
Estas informaciones pueden ser:

  • Nombre del programa.
  • Versión.
  • Fecha.
  • País.
  • Autor.
  • Comentarios generales.
  • Ayuda.
  • Solicitudes al usuario.
  • Mensajes.

Los primeros 5 tipos de información son en general breves,
y los almacenaremos en cadenas de longitud corta (digamos, menos de 32 caracteres).
Los siguientes pueden ser mensajes más extensos,
pero aún así acotaremos su tamaño en menos de, digamos, 1024 caracteres.

Además, puede haber distintos tipos de comentarios, distintos tipos de ayudas, distintos tipos de solicitudes, y distintos tipos de mensajes.
Consideramos estos mensajes extra colocados en un vector de strings.
Este vector es una "lista" que tiene una longitud máxima, que por ahora fijaremos en 16.

(Estamos pensando en una gran generalidad, que nuestro programa GCD no necesita).

Pondremos todo esto dentro de una struct anónima denominada bui.
¿Hace falta una struct?

Estamos pensando en una estructura anónima como un "espacio de nombres", como los que hay en C++.
Agrupamos datos en un bloque que está relacionado a la librería que los define, en este caso bui.h.
De esta manera, los nombres quedan reutilizables para otros archivos, librerías, o programas.

Estamos mostrando preocupación por posibles conflictos en los nombres de los objetos de un programa, que puede crecer de modo descontrolado, y cuyos nombres de variables y funciones pueden empezar a perderse de vista con facilidad, causando conflictos o errores por esta causa.


#define __SHORT_STR_LEN   32  /* Longitud string corta. */
#define  __LONG_STR_LEN 1024  /* Longitud string larga. */
#define __MAX_LIST        16  /* Longitud de listas de varios ítems en bui.h */

struct {
    char
      program_name[__SHORT_STR_LEN],
      program_vers[__SHORT_STR_LEN],
      program_auth[__SHORT_STR_LEN],
      program_date[__SHORT_STR_LEN],
      program_coun[__SHORT_STR_LEN],
      program_purp[__LONG_STR_LEN],
      program_comm[__LONG_STR_LEN],
      program_comm_[__MAX_LIST][__LONG_STR_LEN],
      program_help[__LONG_STR_LEN],
      program_help_[__MAX_LIST][__LONG_STR_LEN],
      program_req[__LONG_STR_LEN],
      program_req_[__MAX_LIST][__LONG_STR_LEN],
      program_mess[__LONG_STR_LEN],
      program_mess_[__MAX_LIST][__LONG_STR_LEN],
      program_err[__LONG_STR_LEN],
      program_err_[__MAX_LIST][__LONG_STR_LEN];
} bui;




También vamos a definir una estructura adicional para el manejo de los "inputs" desde el teclado.
Contendrá estos elementos:

  • Un buffer para albergar caracteres.
  • Una variable entera que albergará el valor devuelto por funciones del tipo scanf(), al intentar leer datos.
  • Una variable "flag" (banderín, señalizador) que indicará el estado de la última operación de lectura (si hay error o no).


#define __INPUT_STR_LEN  130  /* Longitud string datos entrados por teclado. */

struct {
    char buffer[__INPUT_STR_LEN];
    int errno;
    bool error_state;
} bui_input;


El tamaño de 130 para el buffer es razonable, porque las entradas por consola suelen tener un tamaño menor a 128 caracteres.
Si fuera necesario, este valor puede agrandarse, por supuesto.



Pondremos allí la función

bool blank(char* );

que servía para detectar si una string contiene sólo caracteres blancos.
Como es una función de propósito general, la dejaremos visible, o sea, no encapsulada en la librería que estamos desarrollando.


bool blank(char *s) {
    for ( ; *s; ++s)
       if (!isspace(*s))
          /* Se ha encontrado un caracter que no es blanco. */
          return false;
     
    /* s es una string que sólo contiene blancos */
    return true;
}





Definiremos una función sencilla llamada

void bui_show_program_info(void);

Su propósito es mostrar la información básica del programa,
lo cual vendría a ser el contenido de las strings cortas de la estructura bui.


void bui_show_program_info(void) {
    printf("%s %s\n%s %s\n%s\n\n",
       bui.program_name,   bui.program_vers,
       bui.program_date,    bui.program_coun,
       bui.program_auth,
       bui.program_comm
    );
}




Cuando queramos mostrar toda una lista de strings, haremos uso de una función dedicada a esta tarea:

void bui_print_list(char **list);

La función estará definida así:


void bui_print_list(char (*list)[__LONG_STR_LEN]) {
    for (int i = 0; i < __MAX_LIST; i++)
      if (list[i][0])
        printf("%s", list[i]);
}


La sentencia "if" interpuesta bajo el "for" previene contra el caso en que haya cadenas vacías en la lista. En ese caso, no se muestra nada en pantalla.



Puede parecer ridículo usar una instrucción como:

        printf("%s", list[i]);

cuando sería más fácil y directo esto otro:

        printf(list[i]);

Después de todo, list[i] es una string, y printf() puede mostrarla sin problemas.

Pero puede ocurrir que haya directivas de formato en la string que deseamos imprimir, y esto causaría terribles estragos.

¡Peor sería si la cadena a imprimir fuese una string ingresada por el usuario!
Allí tendríamos un comportamiento totalmente impredecible,
pues el usuario podría escribir libremente signos % en todas partes,
y esto causaría destrozos en nuestro programa.

El método de usar printf("%s", str); para imprimir una string str, es más seguro.   :o

Un modo de evitar esta discusión es usar directamente una función como puts(), y asunto arreglado.
No hay que preocuparse por las directivas de formato, ni nada.
En una futura versión de la librería, lo haremos así.



Cada programa ha de seleccionar su propia lista de strings con información que le sea pertinente.
Para eso, a la variable bui que está definida de una vez y para siempre en la librería bui.h,
debemos asignarle valores a cada uno de sus componentes individuales, de alguna manera.

Esto se puede hacer fácilmente mediante un "copiado de caracteres" de una string (la nuestra) en otra (en una de las componentes de bui).

Para copiar cadenas podríamos invocar la librería estándar strings.h.
Pero como sólo nos interesa usar una sencilla función de copiado, y nada más sofisticado que eso,
preferimos definir dicha función a mano, para así no invocar nuevas librerías.


void bui_set_string(char* restrict, const char* restrict);


La palabra restrict pertenece al estándar C99, y se usa para reforzar la seguridad de las funciones que manejan strings.
La idea es que las cadenas no se superpongan entre sí, impidiendo odiosas o imprevistas sobreescrituras de una cadena sobre sí misma en memoria.

Es una prevención útil, pero no la estudiaremos en este momento.

La función de copiado de strings tiene una forma sencilla:


void bui_set_string(char* restrict dest, const char* restrict src) {
    /* Copia src en dest */
    for( ; (*dest = *src) != '\0'; src++, dest++)
      ;
}




Usaremos una función auxiliar para leer cadenas desde el teclado.
Esta función leerá caracteres desde la entrada estándar con gets(),
y el resultado lo guardará en bui_input.buffer.

Además, tomará como parámetro una string req, que será un mensaje para el usuario,
indicando el tipo de dato que se le solicita (es un "request", solicitud):


void bui_gets(char *req) {
    printf("%s", req);
    gets(bui_input.buffer);   
}




Nos interesa calcular el número de directivas en una cadena de formato del tipo que se usan en scanf() y funciones similares.
Esta cantidad se calculará mediante la función

int __bui_N_ARGS(char *);

que toma como parámetro una string, y devuelve el número de directivas % de dicha string.

Para hacer el cálculo, hay que contar todos aquellas situaciones tales que
al caracter actual, si es distinto de '%', le precede un caracter '%'.
Para eso, memorizamos en una variable de estado llamada before,
si es que "antes" (en el caracter inmediato precedente) había un '%'.
Y entonces hacemos el conteo.

El algoritmo se hace así, medio enrevesado, para evitar de forma sencillo el conteo equivocado de casos como "%%", que no deben contarse más de una vez.
(De hecho no debieran contarse ni una sola vez, pero esto lo arreglaremos en una versión futura de la librería).


int __bui_N_ARGS(char *s) {
    int n;
    bool before = false;
   
    for (n = 0; *s; s++)
      if (*s == '%')
        before = true;     
      else {
        if (before)
           n++;
        before = false;   
      }
           
    return n;         
}




En base a nuestra experiencia previa manejando entradas erróneas o no, con gets() y sscanf(),
vamos a definir una macro que servirá para el propósito de ingresar datos desde el teclado,
controlar si han habido errores, y tomar las decisiones pertinentes según los casos.

La macro se llamará BUI_SCANF(),
y sustituirá en tareas a sscanf().

¿Por qué una macro en vez de una función?
El motivo para esto está en que las funciones de la familia de scanf() tienen un número variable de argumentos.
En C99 es más sencillo crear una macro con un número variable de argumentos que ponerse a hacer una función con comportamiento análogo.

Una macro tiene siempre puntos flacos,
es código poco seguro, crackeable de un modo u otro.
De todos modos insistiremos por ahora en este enfoque.

Desarrollaremos la macro en cuestión en el próximo post.



Finalmente un detalle de estilo.
A fin de encapsular las macros tipo constante definidas en bui.h,
vamos a quitar su definición al finalizar el archivo, mediante #undef:


#undef __INPUT_STR_LEN
#undef __SHORT_STR_LEN
#undef __LONG_STR_LEN
#undef __MAX_LIST


18 Agosto, 2013, 05:48 pm
Respuesta #11

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Interacción con el usuario, controlada...

Desarrollaremos aquí la macro que controla lo que el usuario ingresa por teclado.
Intentaremos mantenerla lo más breve y simple que sea posible,
pero también queremos que nos permita tomar decisiones importantes,
que sea versátil...

Las intenciones y objetivos detrás de una pieza de código son lo que realmente hace funcionar correctamente el algoritmo.

Si se sabe lo que una macro o función se supone que tiene que hacer, entonces podemos usarla con confianza, y delegar al programador encargado de diseñar esa macro o función la responsabilidad de programarla correctamente.



La macro BUI_SCANF() aceptará una lista de parámetros, que iremos especificando de a poco.

Lo primero que ha de hacer la macro es leer una línea de texto de la entrada estándar, tecleada por el usuario. Para ello usaremos la función gets().
Pero necesitamos una cadena de caracteres con la suficiente capacidad para albergar el texto tecleado.
Esa cadena será la componente bui_input.buffer, de la estructura previamente definida bui_input.
Ya tiene el tamaño apropiado, y no es necesario que el programador se ponga a definir nuevas variables.
Para eso la hemos puesto como parte inherente de la librería.

Sin embargo, es usual que a una sentencia de lectura de datos le anteceda un mensaje que informa al usuario el tipo de dato que se le solicita, y alguna otra información que pudiera hacer falta.
Esto será especificado en una variable de tipo array de caracteres,
que el programador tiene que especificar a través de un parámetro de la macro,
que llamaremos REQ_MSG.

Así, la sentencia de lectura de datos del teclado será simplemente:

bui_gets(REQ_MSG);

Esta función mostrará en  pantalla el mensaje contenido en REQ_MSG, y luego leerá una línea de caracteres del teclado, guardándola en bui_input.buffer.

Nota: Ya hemos discutido en mensajes previos las razones de por qué hemos evitado el uso directo de scanf(), y cómo es que terminamos usando una combinación de gets() con sscanf().

Aquí sólo estamos reescribiendo esa experiencia previa en forma de una macro, que pueda accederse de manera universal desde cualquier archivo que invoque la librería bui.h.



La siguiente sentencia es lo que ya esperamos: una relectura de los datos mediante sscanf().
El escollo aquí es que sscanf() es una función con un número variable de parámetros.

 ??? ¿Cómo hacemos para pasar a una macro una cantidad variable de parámetros?
 ??? ¿Y cómo los invocamos dentro de la macro?

Lo que se hace es poner al final de la lista de parámetros de la macro 3 puntos suspensivos: ...
Eso informa que la macro acepta una cantidad variable de parámetros.
Para poder "incrustar" todos esos parámetros en alguna parte, basta escribir __VA_ARGS__,
que es una palabra del preprocesador que sirve para sustituir por "lo que sea" que le hayamos arrojado como lista de parámetros a los puntos suspensivos.

La macro tendría esta cabecera, por ejemplo:

#define BUI_SCANF(REQ_MSG, ...)

Suponiendo que hemos puesto esos dichosos puntos suspensivos, podríamos escribir ahora confiados algo así:

sscanf(bui_input.buffer, __VA_ARGS__);

Esa instrucción toma como "entrada de datos" la cadena de caracteres bui_input.buffer,
y luego toma como lista de parámetros a toda la lista variable de parámetros que el programador indica, en reemplazo de los puntos suspensivos.
Un modo de usar la macro sería por ejemplo esta:

BUI_SCANF("Ingrese sus datos!!!\n\n", "%d %f", nn, xx);

Los últimos 3 parámetros: "%d %f", nn, xx
reemplazan a los puntos suspensivos ...
cada vez que en la macro aparece la palabra __VA_ARGS__.
Sería equivalente a haber escrito esto:

sscanf(bui_input.buffer, "%d %f", &nn, &xx);

Nota importante: En lo que sigue vamos a modificar todo este modo de uso.



Para tener un control más fino de la entrada de datos, tenemos que hacer como en posts anteriores: tener en cuenta el valor de retorno de sscanf() para detectar posibles errores.
Si el valor de retorno es 0 ó positivo, indica la cantidad de variables que se pudieron "cargar" correctamente durante el proceso de sscanf().
Si es negativo, indica EOF, que a su vez significa que hubo algún otro tipo de error en la lectura de los datos.

Este dato lo guardaremos en la componente bui_input.errno.
Así que nuestra sentencia debe cambiarse por esta otra:

bui_input.errno = sscanf(bui_input.buffer, __VA_ARGS__);

Para saber si todos las variables han sido correctamente asignadas durante el proceso de sscanf(),
tenemos que observar el valor de bui_input.errno y ver si coincide con la cantidad de parámetros que aparecen en la cadena de formato "%d %f".
Esa cantidad en este caso es 2, pero puede variar, claro está.

Lo que necesitamos es contar la cantidad de veces que aparece la directiva % en la cadena de formato.

Y para eso necesitamos acceder desde la macro a dicha cadena de formato.
No nos sirve el enfoque de "haberla puesto sin nombre junto a toda la lista de parámetros __VA_ARGS__".
Así que ese parámetros le daremos un nombre explícito en la cabecera de la macro, digamos FMT,
y sólo a partir de aquí consideraremos la lista variable de parámetros con los puntos suspensivos ...

La cabecera de la macro quedaría por ahora así:

#define BUI_SCANF(REQ_MSG, FMT, ...)

La sentencia de invocación de sscanf() quedará ahora así:

bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__);

Y ahora calculamos el número de directivas % así:

__bui_N_ARGS(FMT)

Eso fue fácil.  ;D

En realidad la función __bui_N_ARGS() ya la habíamos definido, sabiendo que la íbamos a necesitar.

Nota importante: La función __bui_N_ARGS() no funciona a la perfección todavía. Requiere cambios en versiones futuras.
Reconoce como "variables efectivas" para ser asignadas, casos que no lo son.



Lo que nos interesa es, como dijimos, comparar esa cantidad con el número de error arrojado en bui_input.errno.

Según la definición de sscanf(), sabemos que el entero que retorna en bui_input.errno nunca puede ser mayor que el número de directivas % que aparece en la cadena de formato FMT.

Ahí tenemos, pues, la siguiente aserción lógica:

/* bui_input.errno <= __bui_N_ARGS(FMT)  */

Nunca se da el caso >.

Para saber si hubo un error, tenemos que ver si el lado izquierdo es estrictamente menor que el lado derecho.
El resultado de esto vamos a necesitarlo posteriormente en el programa,
así que lo vamos a guardar en la componente booleana bui_input.error_state:

bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT));

El valor de esta variable es true en caso de que haya algún error,
y es false en caso de que sscanf() haya asignado correctamente todos los valores a cada uno de sus parámetros.



Ahora tenemos que tomar una decisión.
Si bui_input.error_state es false, no hacemos nada, y dejamos que el programa fluya.
Si es true, hay dos opciones: o bien el programa termina, o bien muestra un mensaje de error y continúa normalmente.
En este último caso, la rutina principal que ha invocado la macro tiene la responsabilidad de verificar si ha habido o no un error (mirando el valor de bui_input.error_state), y entonces decidir qué hace en esa situación.
(Lo que nosotros venimos haciendo hasta ahora es "saltearnos" el trozo de código del bucle principal mediante un continue;, que salta al principio del bucle para recomenzar).

El esquema de decisión sería éste:


       if (bui_input.error_state)   
          if ( (evaluar_condicion_de_terminacion_del_programa ) )       
              /* Terminar el programa */                   
          else
              /* Mostrar mensaje de error */
       else;




La condición para terminar el programa es algo que debe dejarse "abierto a todas las posibilidades",
ya que esto es decisión de diseño del programador.
No puede ser la librería bui.h quien decida cuál es el mejor requisito para terminar un programa, pues es una librería de servicios.

Sin embargo, podemos restringir un poco el universo de ocurrencias del programador,
diciendo que una "condición de terminación" es algo bien específico, por ejemplo:

Una función que acepta como entrada un parámetro de tipo cadena de caracteres,
y como salida envía un valor booleano, indicando true para "terminar" y false para "no terminar".


Supongamos que, como hasta ahora, queremos que el programa termine cuando el usuario ha ingresado una cadena de caracteres con puros blancos.
En este caso, podemos usar la función blank(), que por suerte ya la tenemos definida y funcionando correctamente.

Lo que haremos ahora será pasar el nombre de la función, es decir blank,
como un parámetro a la macro BUI_SCANF().
Ese parámetro indicará, pues, el nombre de una función cuyo cometido es dar una condición verdadera o falsa, para terminar o no el programa.
Entonces la cabecera de la macro se modificaría así:

#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, FMT, ...)

Como TERMINATION_FUNC es sólo el "nombre" de una función, podemos intercalarlo alegremente dentro de la macro, usándola cuidadosamente para llamar funciones.
Sabiendo de antemano que esa función admite 1 parámetro de tipo cadena de caracteres, podemos escribir con tranquilidad lo siguiente:

TERMINATION_FUNC (bui_input.buffer)

Eso equivaldrá a reemplazar el parámetro TERMINATION_FUNC por blank, y entonces equivale a haber invocado:

blank (bui_input.buffer)

Debemos tener mucho cuidado con este tipo de manipulaciones.
Vemos, pues, que el uso de las macros es riesgoso, porque nada impide que un programador ponga cualquier cosa como parámetro. ¿Qué pasa si no pone una función, sino un float, o un puntero?
Por ahora dejaremos esas preguntas sin responder.

Concentrémonos en lograr que las cosas funcionen, y después veamos los reparos técnicos.

El esquema de decisión tiene ahora este otro aspecto:


       if (bui_input.error_state)   
          if ( TERMINATION_FUNC (bui_input.buffer) )       
              /* Terminar el programa */                   
          else
              /* Mostrar mensaje de error */
       else;


Vemos que, cualquiera sea la función que indiquemos para determinar la condición de terminación,
va a actuar siempre sobre la variable bui_input.buffer, que es una cadena de caracteres declarada en la librería bui.h.

Es decir que las "condiciones de terminación" son condiciones establecidas sobre la cadena de caracteres que el usuario ha ingresado por teclado.
Esto es un diseño lógico, ya que esperamos que sea una decisión del usuario la que termine el programa.
Lo que puede cambiar es el tipo de entrada que el programa principal elige como indicador de "quiero terminar este programa de una vez por todas".



Una observación importante es que una macro no es una función.
Ni tampoco es una pieza de código que tenemos claramente a la vista.
Una macro es un caballo de Troya, del que no se sabe qué diablos saldrá de su interior.

En nuestro versión 1.10 de GCD habíamos puesto sentencias como break, continue, o return.

Esas tres sentencias típicas de "quiebre" del flujo normal y secuencial del programa deben evitarse adentro de una macro, porque no se sabe cómo van a repercutir en la rutina principal que la invoca.

Por ejemplo, el caso de break es fuente segura de problemas.
Si la rutina que la invoca está dentro de un bloque while(), la sentencia break causará que salgamos del while().
Pero si estamos en un switch(), que a su vez está dentro del while(), no se consigue el mismo efecto, porque el break sólo servirá para salir del switch().

Poniendo break, continue ó return dentro de las sentencias de una macro no permite predecir con exactitud hacia dónde se producirá el "salto".


La solución a este dilema es otorgar un mayor control sobre los saltos.
Esto se puede lograr con etiquetas claramente definidas y usando dentro de la macro una sentencia goto, que se dirijan hacia esa etiqueta y no otra.
Ahí se acaba toda posible incertidumbre o ambigüedad.

Recordemos que las etiquetas y los saltos goto tienen sentido en C sólo dentro del bloque que abarca una función.

Lo que deberíamos hacer es pasar el nombre de la etiqueta como un parámetro más a la macro BUI_SCANF, digamos TERMINATION_LABEL, en la cabecera:

#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, FMT, ...)

Y dentro de la macro, en el lugar donde se consigue una condición de "terminación", poner la sentencia:

goto TERMINATION_LABEL;

Esto hará el trabajo.
Nuestro esquema de decisión se va completando mejor, y ahora tenemos esto:


       if (bui_input.error_state)   
          if ( TERMINATION_FUNC (bui_input.buffer) )       
              goto TERMINATION_LABEL;
          else
              /* Mostrar mensaje de error */
       else;


Ahora, si en nuestro programa ponemos una etiqueta llamada fin_programa:
antes del final, invocaríamos a BUI_SCANF() así:


int main(void) {

    BUI_SCANF("Ingrese sus datos aquí: \n\n", blank, fin_programa, "%d %f", nn, xx);
   
    /* sentencias varias... */

fin_programa:

    return 0;
}




Todos estamos acostumbrados a oír la eterna canción de

"No uses goto en la programación."

Eso se repite una y otra vez como un mantra religioso.

En realidad en la programación "hay que hacer lo que hay que hacer", según la situación que corresponda, para bien del programa que estamos desarrollando.
Me causan mucha risa  ;D ;D ;D las prevenciones morales en el terreno informático.  >:D >:D >:D

En realidad lo que no habría que usar son las macros.  :o :o :o
Esas sí que son peligrosas.

Pero entonces, ya que estamos haciendo un diseño basado en una macro,
tenemos que ponernos en situación, y advertir que hay acciones peligrosas dentro de una macro.
En este caso, el uso de sentencias aparentemente seguras como break, continue, return,
conducen ahora a resultados impredecibles en el momento del diseño,
y lo más saludable es controlar los saltos con etiquetas bien especificadas,
para decirle a la macro exactamente a dónde queremos que vaya,
y esto trae como consecuencia la necesidad de hacer los saltos con goto hacia esas etiquetas.

En este caso, lo más "seguro" es usar goto.



En caso de que la condición de terminación no se dé,
la alternativa es mostrar un mensaje de error que informe al usuario lo que ha ocurrido,
y que le indique además cómo salir del error, o qué hacer a continuación.

Este mensaje de error será una cadena de caracteres que debe elegirse desde la rutina invocadora,
y por lo tanto es un parámetro adicional, digamos ERROR_MSG, que tendremos que pasar a la macro BUI_SCANF().
La cabecera quedará así:

#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...)

Ahora el esquema de decisión queda completo, así:


       if (bui_input.error_state)
          if (TERMINATION_FUNC (bui_input.buffer))       
              goto TERMINATION_LABEL;                     
          else
              printf(ERROR_MSG);                         
       else;   




Habiendo explicado todos los aspectos de la macro BUI_SCANF(), estamos en condiciones de mostrarla en su forma final, que sería ésta:


#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...) { \
       bui_gets(REQ_MSG);                                \
       bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__); \
       \
       bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT)); \
       if (bui_input.error_state)    \
          if (TERMINATION_FUNC (bui_input.buffer))        \
              goto TERMINATION_LABEL;                     \
          else \
              printf(ERROR_MSG);                          \
       else;   \
    }


Todos los caracteres \ que aparecen al final de cada línea son necesarios en la definición de una macro, para indicar que en realidad se trata de una línea que "continúa debajo".
Hemos puesto el código de la macro "entre llaves", cuando no es estrictamente necesario,
ya que no es una función.
Pero el uso de llaves encierra bien las sentencias, dando lugar a código más seguro, evitando errores sintácticos indeseables o inentendibles.



La librería bui.h está lista.
Le pondemos número de versión 1.20, para seguir con la numeración que traíamos desde GCD,
aunque no tengan ahora nada que ver una cosa con la otra.
Ya hemos independizado por completo la interface de usuario con la rutina matemática GCD.
El archivo luce así (en spoiler):

Spoiler
bui0120.h:


/* ========================================================================= */
/* BUI.H 1.20 (Basic User Interface)
/*
/* Esta librería da una interface básica para presentar programas simples en C
/*
/* 2013/ago/18
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>

#define __SHORT_STR_LEN   32  /* Longitud string corta. */
#define  __LONG_STR_LEN 1024  /* Longitud string larga. */
#define __MAX_LIST        16  /* Longitud de listas de varios ítems en bui.h */

struct {
    char
      program_name[__SHORT_STR_LEN],
      program_vers[__SHORT_STR_LEN],
      program_auth[__SHORT_STR_LEN],
      program_date[__SHORT_STR_LEN],
      program_coun[__SHORT_STR_LEN],
      program_purp[__LONG_STR_LEN],
      program_comm[__LONG_STR_LEN],
      program_comm_[__MAX_LIST][__LONG_STR_LEN],
      program_help[__LONG_STR_LEN],
      program_help_[__MAX_LIST][__LONG_STR_LEN],
      program_req[__LONG_STR_LEN],
      program_req_[__MAX_LIST][__LONG_STR_LEN],
      program_mess[__LONG_STR_LEN],
      program_mess_[__MAX_LIST][__LONG_STR_LEN],
      program_err[__LONG_STR_LEN],
      program_err_[__MAX_LIST][__LONG_STR_LEN];
} bui;

#define __INPUT_STR_LEN  130  /* Longitud string datos entrados por teclado. */

struct {
    char buffer[__INPUT_STR_LEN];
    int errno;
    bool error_state;
} bui_input;

bool blank(char* );

void bui_show_program_info(void);
void bui_print_list(char (*list)[__LONG_STR_LEN]);
void bui_set_string(char* restrict, const char* restrict);

/* Macro:
/* BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...)
/* */


/* ========================================================================= */

void bui_show_program_info(void) {
    printf("%s %s\n%s %s\n%s\n\n",
       bui.program_name, bui.program_vers,
       bui.program_date, bui.program_coun,
       bui.program_auth,
       bui.program_comm
    );
}

void bui_print_list(char (*list)[__LONG_STR_LEN]) {
    for (int i = 0; i < __MAX_LIST; i++)
      if (list[i][0])
        printf("%s", list[i]);
}

void bui_set_string(char* restrict dest, const char* restrict src) {
    /* Copia src en dest */
    for( ; (*dest = *src) != '\0'; src++, dest++)
      ;
}

void bui_gets(char *req) {
    printf("%s", req);
    gets(bui_input.buffer);   
}

int __bui_N_ARGS(char *s) {
    int n;
    bool before = false;
   
    for (n = 0; *s; s++)
      if (*s == '%')
        before = true;     
      else {
        if (before)
           n++;
        before = false;   
      }
           
    return n;         
}

bool blank(char *s) {
    for ( ; *s; ++s)
       if (!isspace(*s))
          /* Se ha encontrado un caracter que no es blanco. */
          return false;
     
    /* s es una string que sólo contiene blancos */
    return true;
}

#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...) { \
       bui_gets(REQ_MSG);                                \
       bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__); \
       \
       bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT)); \
       if (bui_input.error_state)    \
          if (TERMINATION_FUNC (bui_input.buffer))        \
              goto TERMINATION_LABEL;                     \
          else \
              printf(ERROR_MSG);                          \
       else;   \
    }

/* Quitamos las definiciones de los símbolos definidos en la librería */
/* para que queden inaccesibles desde archivos externos. */

#undef __INPUT_STR_LEN
#undef __SHORT_STR_LEN
#undef __LONG_STR_LEN
#undef __MAX_LIST


[cerrar]



La versión 1.20 del programa GCD ahora quedará muy breve, pues se limita a invocar librerías, funciones y macros, y controlar el flujo del programa.

Sin embargo, a nuestro programa le queda todavía una tarea importante:

* Definir todas las cadenas de caracteres que dan información al usuario.

Esto lo haremos en una función llamada start(),
en donde definiremos las componentes que nos interesen de la estructura bui.
Veamos el programa completo directamente, ya que será fácil de interpretar:

Spoiler
gcd0120.c:


/* ========================================================================= */
/* GCD 1.20
/*
/* Este programa calcula el máximo común divisor de dos números enteros.
/*
/* 2013/ago/17
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
 
#include "bui0120.h"
#include "gcd0110.h"

void start(void);

int main(void) {
   start();

   do {
     int m, n;

     BUI_SCANF( bui.program_req,
                blank, end_program, bui.program_err,
                "%d %d", &m, &n
     );     
     if (bui_input.error_state)
       continue;   
         
     int ans = gcd(m, n);
     printf(((ans >= 0)? "gcd(%i,%i) = %i\n\n": "gcd(0, 0) = INFINITO\n\n"), m, n, ans);

   } while (1); 

end_program:
       
   return 0;
}

void start(void) {
   bui_set_string(bui.program_name, "GCD");
   bui_set_string(bui.program_vers, "01.20");
   bui_set_string(bui.program_auth, "Argentinator");
   bui_set_string(bui.program_date, "2013/Ago/18");
   bui_set_string(bui.program_coun, "");
   bui_set_string(bui.program_comm,
     "Este programa calcula el M.C.D. de dos nros. enteros\n"
     "Si ambos valores son nulos, el resultado es INFINITO.\n"
   );
   bui_set_string(bui.program_req,
     "Escriba dos enteros separados por un caracter blanco\n"     
     "(o digite un ESPACIO seguido de ENTER para terminar).\n\n"
   );
   bui_set_string(bui.program_err,
     "\nDatos no validos.\n"
     "Se requieren dos numeros enteros.\n"
     "Intente nuevamente.\n\n"   
   );
   
   bui_show_program_info();
}


[cerrar]

Vemos que en start() hacemos uso de las funciones bui_set_string(), que usamos para asignar cadenas de caracteres concretas a las componentes de la estructura gui.

No hace falta asignar valores a todas las componentes.

Luego invocamos la función bui_show_program_info(), que muestra los datos básicos del programa.
Esos datos al menos sí tendrían que ser bien asignados en las líneas precedentes.

Observemos cómo el programa se controla con un bucle que ahora es muy sencillo de interpretar:

* Primero lee datos del teclado con BUI_SCANF(),
* luego verifica si hubo un error (y en tal caso reinicia el bucle),
* y si toda está correcta realiza el cálculo del máximo común divisor y muestra los resultados.
* Por último, el bucle se repite indefinidamente.

A nuestro programa le faltan algunos comentarios, por ejemplo unos que informen un poco mejor sobre las condiciones bajo las cuales el programa termina. Esto lo haremos luego.


18 Agosto, 2013, 09:17 pm
Respuesta #12

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Cambios nulos de versión...

Si hacemos cambios nulos a un programa, digamos, poniéndole comentarios, agregando líneas en blanco, retocando estéticamente las instrucciones,
pero no hacemos ningún cambio que cambie la sintaxis de fondo del programa, ni nada que afecta al comportamiento cuando el programa se ejecuta.
¿Vale la pena consignarlo como un cambio de versión?

Yo digo que sí.  :P

Los cambios nulos introducen nuevas ideas relativas al programa,
mejoran la comprensión del mismo, y sirven para aclarar puntos oscuros del funcionamiento del mismo.
Estas aclaraciones sirven además como punto de apoyo para realizar futuros cambios reales en el programa, o inspirar métodos diferentes.

En este post vamos a hacer retoques de efecto nulo a la librería bui.h.
También arreglaremos efectivamente algunos pequeños detalles "de verdad".




En esta versión he cambiado printf("%s", s); por puts(s); en bui_print_list().
La función puts() agrega un caracter fin de línea al final de la cadena s.
Este comportamiento ha de quedar debidamente documentado para evitar sorpresas.

El significado de bui_input.error_state es que "en la última operación de lectura hecha con BUI_SCANF() ha surgido un error".
Para que este significado permanezca siempre "verdadero" (como un invariante del programa) en todo instante de la ejecución del programa, decidimos inicializarlo a false.

En C99 podemos inicializar componentes individuales de una struct, así:


struct {
    char buffer[__INPUT_STR_LEN];
    int errno;
    bool error_state;
} bui_input = { .error_state = false };


Puede parecer extraño inicializar sólo esa variable, y dejar las otras "al aire".
Pero en realidad lo que importa es por qué decidimos inicializarla: es para mantener el mismo significado lógico a lo largo de todo el programa.

Este significado puede verse alterado si el programador cambia manualmente el valor de la variable.
Eso está documentado, y obviamente no se recomienda.
Como sea, es una práctica poco segura, y es culpa nuestra, de los diseñadores de la librería bui.h que esto esté así de desprolijo.

En todas partes documentaremos advertencias de que la función __bui_N_ARGS() no funciona exactamente como debería: no maneja todos los casos.
Esto repercute en que la cadena de formato que le pasemos a BUI_SCANF() no puede ser cualquiera, sino que debe evitar algunas directivas especiales como: %%, %n, %*.

Agregamos a la documentación del programa explicaciones de qué son y qué hacen todos los objetos que figuran en la interface de la librería.
Se ponen recomendaciones de uso, advertencias de malos usos, e incluso información de mejoras que deben hacerse en el futuro.



Hay una presentación de la librería (1er bloque),
luego la interface principal de la librería (2do bloque),
y finalmente la implementación de las funciones y macros de la librería (3er bloque).

En el 1er bloque se explica en forma genérica qué objetos hay en la librería y para qué sirven.

En el 2do bloque se comentan las intenciones y modo de uso de los objetos definidos en la librería.
Se incluyen los prototipos de funciones y macros (éstas sólo en comentarios).
Se explica qué es cada parámetro (de ser necesario),
y se indica cuál es el resultado esperado.
No se colocan aquí las implementaciones de las funciones o macros (a menos que sean triviales).

En el 3er bloque se desarrollan las funciones y macros, y se ponen comentarios técnicos.
Por ejemplo, se insertan aserciones lógicas o implicaciones.

Al final de la función bui_set_string() pusimos "por afuera" del cuerpo de la función un comentario que explica qué le pasa a los parámetros dest y src pasados a la función.
No se puede poner esto dentro de la función, porque las direcciones de memoria apuntan a cualquier parte ahí.
Sólo cuando la función retorna el control a la rutina que la llamó es que podemos hablar de las direcciones de memoria originales de dest y src. En dichas direcciones quedan albergadas dos cadenas de caracteres, que tienen idéntica información y longitud.

Este tipo de comentarios los ponemos pegaditos al final del cuerpo de la función,
y añadiendo una flecha: --->, así:


void bui_set_string(char* restrict dest, const char* restrict src) {
    for( ; (*dest = *src) != '\0'; src++, dest++)
      ;
}
/* ---> OUT: dest == src, strlen(dest) == strlen(src) */

(resto del archivo...)




Hay comentarios precedidos con [!].
Con esto querremos indicar una advertencia: la rutina o resultado obtenido no es perfecto.
Es una señal que dejaremos para indicar que debe mejorarse ese detalle en futuras versiones.

Otros comentarios están precedidos por [#].
Con esto querremos indicar esta advertencia:

Se espera aquí el siguiente rango o tipo de datos: (...)
Si se usa la macro o función de otra manera, los resultados son impredecibles.


Sobretodo esa advertencia aparecerá cuando usemos parámetros dentro de las macros.
Estos parámetros no tienen un tipo de datos asociado, ni siquiera tienen por qué ser un dato de algún tipo, sino que puede ser casi cualquier cosa imaginable.

Recordemos que el preprocesador nos da un lenguaje de macros que muy poco tiene que ver con el lenguaje C. Van por caminos muy distintos en la vida.


En realidad esto no tiene mucha solución dentro del estándar C99.
Pero podemos dejarlo así, especulando conque en el futuro, el estándar C11 (ISO C del año 2011) agregará unas capacidades extra a las macros, para detectar tipos de datos en los parámetros.  ;) ;)



Nuestro diseño es tal que ocurren algunos efectos "colaterales".
Se modifican variables de las estructuras bui y bui_input desde diversos lugares del programa,
no siempre visibles.
En algunos casos lo hemos advertido en los comentarios.



El exceso de comentarios puede ser engorroso, hacer que un programa sea difícil de leer o digerir.
Pero esto no es tan grave, ya que es sencillo realizar un programa que "filtre" los comentarios de un modo u otro, y nos devuelva el mismo programa, pero limpio de comentarios.

Por otra parte, considero que el espíritu del programa es lo que más documentación merece,
porque es lo que permite guiar las futuras correcciones, mejoras o cambios de toda índole.


También tiene que estar bien documentada la interface de la librería: qué hace, cómo lo hace, qué se espera que haga, ejemplos típicos de uso, advertencias de limitaciones o fuentes de error, etc.



He aquí el resultado final, a ver si les gusta:

Spoiler
bui0121.h:


/* ========================================================================= */
/* BUI.H 1.21 (Basic User Interface)
/*
/* Esta librería da una interface básica para presentar programas simples en C
/*
/* 2013/ago/18
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
/*
/* Esta librería provee una interface sencilla y sólida
/* para intercambio de información con el usuario por la E/S estándar.
/*
/* Hay una macro principal BUI_SCANF(), que reemplaza a la función scanf(),
/* y se encarga de gestionar la entrada por teclado de forma segura,
/* y gestionar situaciones de error de forma genérica.
/*
/* La estructura bui{} contiene campos de tipo char[], de longitud fija,
/* que pueden usarse para guardar en forma permanente
/* los mensajes e informaciones que necesita el programa
/* (nombre, vesión, autor, etc.; comentarios, ayudas, errores, mensajes, etc.)
/*
/* La estructura bui_input{} contiene campos
/* que controlan la entrada por teclado, y contienen señales de error.
/*
/* void bui_set_string(char *, char *):
/*    Función que se usa para asignar valores a los campos de bui{}.
/*
/* void bui_show_program_info(void):
/*    Función que muestre información básica del programa (contenida en bui{}).
/*
/* void bui_print_list(char (*list)[__LONG_STR_LEN]):
/*    Función que se usa para mostrar datos con formato de lista en bui{}.
/*
/* bool blank(char* ):
/*    Función de propósito general que indica si
/*    todos los caracteres de una cadena son blancos,
/*    siguiendo estrictamente las especificaciones
/*    de la función estándar isspace(),
/*    de la librería estándar ctype.h, según el estándar C99.
/*
/* ========================================================================= */

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>

/* */
/* struct { ... } bui;
/* ===================
/*
/* Es una estructura anónima que contiene strings.
/* Las strings de longitud "corta" se usan para información básica del programa.
/* Las strings de longitud "larga" se usan para información más compleja.
/*
/* program_name, program_vers, program_date, program_coun, program_auth:
/*   Son strings de longitud "corta", y se refieren a:
/*   Nombre (del programa), Versión, Fecha, País, Autor.
/*
/* program_purp, program_comm, program_help,
/* program_req, program_mess, program_err:
/*   Son strings de longitud "larga", y se refieren a:
/*   Propósito (del programa), Comentarios, Ayuda,
/*   Solicitudes al usuario (requests), Mensajes al usuario, Mensajes de error.
/*
/* En programas más complejos pueden requerirse varios mensajes distintos
/* del tipo de los indicados, y por eso se añaden listas de mensajes con
/* la misma temática, por si hicieran falta:
/*
/* program_comm_, program_help_,
/* program_req_, program_mess_, program_err_:
/*   Cada uno de ellos es un array de __MAX_LIST (16) strings "largas", para
/*   añadir distintos tipos de comentarios, ayudas, mensajes, errores, etc.
/*
/* Las macros constantes __SHORT_STR_LEN, __LONG_STR_LEN, __MAX_LIST,
/* albergan el tamaño prefijado de todas estas strings.
/* Sus valores no son accesibles desde el "exterior",
/* porque se "undefinen" al final del archivo.
/*
/* */

#define __SHORT_STR_LEN   32  /* Longitud string corta. */
#define  __LONG_STR_LEN 1024  /* Longitud string larga. */
#define __MAX_LIST        16  /* Longitud de listas de varios ítems en bui.h */

struct {
    char
      program_name[__SHORT_STR_LEN],
      program_vers[__SHORT_STR_LEN],
      program_date[__SHORT_STR_LEN],
      program_coun[__SHORT_STR_LEN],
      program_auth[__SHORT_STR_LEN],

      program_purp[__LONG_STR_LEN],
      program_comm[__LONG_STR_LEN],
      program_comm_[__MAX_LIST][__LONG_STR_LEN],
      program_help[__LONG_STR_LEN],
      program_help_[__MAX_LIST][__LONG_STR_LEN],
      program_req[__LONG_STR_LEN],
      program_req_[__MAX_LIST][__LONG_STR_LEN],
      program_mess[__LONG_STR_LEN],
      program_mess_[__MAX_LIST][__LONG_STR_LEN],
      program_err[__LONG_STR_LEN],
      program_err_[__MAX_LIST][__LONG_STR_LEN];
} bui;

/* */
/* struct { ... } bui_input;
/* =========================
/*
/* Es una estructura anónima que sirve para gestionar la entrada estándar.
/* Sus campos son:
/*
/*    char buffer[]:
/*          Un array de caracteres para albertar los datos de entrada.
/*    int errno:
/*          Contiene el resultado de la operación de entrada,
/*          el cual coincide con el que generaría sscanf(),
/*          siempre que su valor sea modificado por las operaciones "internas"
/*          de éste archivo de librería.
/*    bool error_state:
/*          Es un "flag" (banderín) que informa si la última operación
/*          de entrada ha tenido errores (true) o ha sido exitosa (false).
/*          Para ser consecuentes con este significado,
/*          se inicializa su valor a "false" al principio del programa.
/*
/* La longitud de la cadena "buffer" es __INPUT_STR_LEN,
/* que es una macro constante inaccesible desde el "exterior",
/* pues se "undefine" al final del archivo.
/* Tiene un valor de 130, suficiente para la consola típica de 128 caracteres,
/* más 1 caracter nulo que agrega al final la función gets().
/* Si se va a correr el programa en un entorno donde la consola admita entradas
/* más extensas, este valor no sería suficiente.
/* (Mas, sería preferible recortar la entrada, antes que agrandar el buffer.)
/*
/* */

#define __INPUT_STR_LEN  130  /* Longitud string datos entrados por teclado. */

struct {
    char buffer[__INPUT_STR_LEN];
    int errno;
    bool error_state;
} bui_input = { .error_state = false; };

/* bui_set_string(char* dest, char* src):
/*     Copia la cadena src en la cadena dest.
/*     Su propósito es asignar valores a las strings de la estructura bui{}.
/*     Ejemplo:
/*       bui_set_string(bui.program_comm, "Este programa calcula el M.C.D.\n");
/* */
void bui_set_string(char* restrict, const char* restrict);

/* bui_show_program_info():
/*     Muestra en pantalla la información básica del programa,
/*     con un formato predefinido:
/*
/* NOMBRE VERSIÓN
/* FECHA PAÍS
/* AUTOR
/*
/* Los datos consignados son leídos directamente de los campos de gui{}:
/*    program_name, program_vers, program_date, program_coun, program_auth.
/*
/* Al final agrega una línea en blanco como separador.
/* */
void bui_show_program_info(void);

/* bui_print_list():
/*     Muestra en pantalla todas las strings de un array de strings,
/*     tal que cada string tiene longitud __LONG_STR_LEN.
/*     Las muestra en secuencia según su índice de array, de 0 a __MAX_LIST.
/*     Agrega un caracter fin_de_línea \n al final de cada ítem de la lista.
/*     Si un ítem es una cadena vacía (""), no hace nada.
/* */
void bui_print_list(char (*list)[__LONG_STR_LEN]);

/* Macro:
/* BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...)
/*
/* Macro para la entrada de datos, al estilo de scanf() o sscanf().
/* (Es decir, acepta un número variable de parámetros).
/*
/* REQ_MSG:
/*    Es una string (char*) que contiene un mensaje al usuario
/*    con una solicitud de que ingrese datos de cierto tipo.
/*    Si no se ingresa un (char*) el comportamiento de la macro es desconocido.
/* TERMINATION_FUNC:
/*    Es el nombre de una función del tipo: (bool) (char*).
/*    Es decir, una función que acepta un char* como único parámetro,
/*    y que retorna un bool.
/*    Si se pasan otros tipos de funciones u objetos,
/*    el comportamiento de la macro es desconocido.
/* TERMINATION_LABEL:
/*    Indica una etiqueta a la cual la macro intentará saltar
/*    tras hallar una orden del usuario de "terminación" del programa.
/* ERROR_MSG:
/*    Es una string (char*) que contiene un mensaje de error,
/*    el cual se mostrará al usuario en caso de ingreso erróneo de datos.
/* FMT:
/*    Es una cadena de formato que funciona igual que las de scanf().
/* ...:
/*    Número variable parámetros, en donde se han de consignar
/*    las direcciones de memoria de las variables a ser asignadas durante
/*    el proceso de lectura de datos
/*    (según las directivas de tipos de datos consignados en FMT).
/*
/* Para usar la macro BUI_SCANF() se deben consignar todos los parámetros
/* arriba explicados, y además al menos 1 parámetro más en la lista variable.
/* La macro lee una línea de la entrada estándar (hasta el 1er fin de línea).
/* Estos caracteres se guardan en bui_input.buffer.
/* Luego se "releen" estos caracteres, y se intenta convertirlos
/* en valores apropiados, según indique la cadena de formato FMT,
/* pasando estos valores a la lista variable de parámetros.
/* El método en que se realiza esta asignación es idéntico al de sscanf().
/* El resultado de esta operación es un entero (int),
/* igual al valor que generaría una llamada a sscanf().
/* Este valor queda guardado en:
/*         bui_input.errno
/* Se calcula la cantidad de asignaciones esperadas
/* (esto se logra calculando la cantidad de caracteres '%' de FMT
/* que realmente se usarán para asignar valores a variables).
/* El cálculo se hace con la función:
/*        int __bui_N_ARGS(char* );
/*
/* Se compara este valor con el almacenado en bui_input.errno,
/* y el resultado se guarda como un valor bool en
/*        bui_input.error_state
/* Su valor es "true" cuando la comparación de los dos valores falla.
/* Esto es indicativo de "error" de lectura.
/*
/* Cuando hay un error de lectura hay 2 alternativas:
/*    * Reconocer una intención por parte del usuario de
/*      "terminación del programa"
/*      verificando mediante la función TERMINATION_FUNC.
/*      En este caso se "salta" a la etiqueta TERMINATION_LABEL.
/*    * Enviar al usuario el mensaje de error ERROR_MSG.
/*
/* La rutina que llamó a la macro BUI_SCANF() tiene que verificar
/* el valor de bui_input.error_state, y actuar en consecuencia.
/*
/* Ejemplo de uso:
/*
/* #include bui0120.h
/*
/* int main(void) {
/*     float x, y, z;
/*
/*     BUI_SCANF("Ingrese 3 números: ",
/*               blank, end_prog, "Error! Intente otra vez!\n",
/*               "%f %f %f", &x, &y, &z
/*     );
/*     if (!bui_input.error_state)
/*         printf("Datos correctos!\nSu promedio es: %f\n\n", (x+y+z)/3);
/*     else
/*         printf("No puedo calcular nada con esa actitud tuya!! :( \n\n");
/* 
/*  end_prog:
/*   
/*     return 0;   
/* }
/*
/* Precauciones:
/* =============
/*      La cadena de formato FMT sólo debe contener directivas
/*      que efectivamente asignan un valor a un argumento.
/*      Si no, se obtendrán resultados erróneos,
/*      debido a que la versión actual no reconoce con exactitud
/*      los tipos especiales de directivas de sscanf(), como %%, %n, %*
/* */

/* blank():
/*     Decide si la cadena de caracteres tomada como parámetro
/*     contiene sólo caracteres "blancos" (y retorna true), o no (false).
/*     El significado de "caracter blanco" es el mismo que
/*     interpreta isspace() de la librería estándar ctype.h.
/* */
bool blank(char* );


/* ========================================================================= */
/* Implementación:
/* */

void bui_show_program_info(void) {
    printf("%s %s\n%s %s\n%s\n\n",
       bui.program_name, bui.program_vers,
       bui.program_date, bui.program_coun,
       bui.program_auth,
       bui.program_comm
    );
/* Los datos se muestran con el formato:
/* ----------------------------------------- */
/* NOMBRE VERSIÓN
/* FECHA PAÍS
/* AUTOR
/*
/* ----------------------------------------- */
}

void bui_print_list(char (*list)[__LONG_STR_LEN]) {
    for (int i = 0; i < __MAX_LIST; i++)
      if (list[i][0])
         /* list[i] == "" */
         /* Como puts() agrega un fin de línea,                       */
         /* se desea que este efecto no ocurra si la cadena es vacía: */
         puts(list[i]);
}

void bui_set_string(char* restrict dest, const char* restrict src) {
    /* Copia src en dest */
    /* Las direcciones de las strings originales no son alteradas. */
    /* Sin embargo se modifica el contenido de dest.               */
    /* (No se cambia el contenido de src).                         */
    /* Se realiza la asignación caracter a caracter, */
    /* luego se compara el valor asignado contra 0,  */
    /* en cuyo caso el proceso termina.              */
    /* Si no termina, se avanza una posición de memoria en cada string. */
    for( ; (*dest = *src) != '\0'; src++, dest++)
      ;
}
/* ---> OUT: dest == src, strlen(dest) == strlen(src) */

/* La siguiente función tiene ciertos efectos colaterales: */
/* [*] modifica bui_input.buffer                           */
/*                                                         */
/* [!] El uso de gets() no es seguro: */
/* [*] permite al usuario ingresar cadenas de longitud mayor que el buffer, */
/*     causando errores en tiempo de ejecución.                             */
void bui_gets(char *req) {
    printf("%s", req);
    gets(bui_input.buffer); /* Unsafe... */
}

int __bui_N_ARGS(char *s) {
    int n;
    bool before = false;
   
    for (n = 0; *s; s++)
      /* n == 0 ---> before == false */
      /* n > 0  ---> [ *(s-1) == '%' <----> before == true ]  */
      if (*s == '%')
        /* Recordar que se ha encontrado un signo '%' en esta posición, */
        /* pero no tomar ninguna acción.                                */
        before = true;     
      else {
        /* El caracter actual no es '%' */   
        if (before)
           /* *(s-1) == '%' (el caracter previo era un '%') */
           /* Directiva % detectada: contarla */
           n++;
        before = false;
        /* Se registra para la iteración siguiente */
        /* que el caracter actual no es un '%'     */
      }
    /* n == número de directivas % halladas en s.                        */
    /* [!] Requiere mejoras, pues cuenta casos de directivas especiales, */
    /* que no hacen asignaciones a argumentos de sscanf().               */
    /* (Por ejemplo, no se deben contar los casos de %%, %n, %*).        */
           
    return n;         
}

bool blank(char *s) {
    for ( ; *s; ++s)
       if (!isspace(*s))
          /* Se ha encontrado un caracter que no es blanco. */
          return false;
     
    /* s es una string que sólo contiene blancos (al "estilo" isspace()) */
    return true;
}

#define BUI_SCANF(REQ_MSG,                                        \
                  TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, \
                  FMT, ...) {                                     \
       /* [#] typedef(REQ_MSG) == (char*)                         */ \
       bui_gets(REQ_MSG);                                            \
       /* Una línea de datos entrada por teclado ha sido guardada */ \
       /* en bui_input.buffer.                                    */ \
       /* [#] typedef(FMT) == const char*                         */ \
       /* [#] __VA_ARGS__  == lista de punteros a variables       */ \
       bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__); \
       /* bui_input.errno: contiene valor de significado          */ \
       /*                  equivalente al que retornaría sscanf() */ \
       /* __bui_N_ARGS(FMT) == número de directivas en FMT        */ \
       /*     (no da el número exacto de argumentos esperados...) */ \
       bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT));\
       /* [#] typedef(TERMINATION_FUNC) == (bool) (char*)         */ \
       /* [#] TERMINATION_LABEL: es una etiqueta válida.          */ \
       /* [#] typedef(ERROR_MSG) == (char*)                       */ \
       if (bui_input.error_state)    \
          if (TERMINATION_FUNC (bui_input.buffer))        \
              goto TERMINATION_LABEL;                     \
          else \
              printf(ERROR_MSG);                          \
       else;   \
    }

/* Quitamos las definiciones de los símbolos definidos en la librería */
/* para que queden inaccesibles desde archivos externos. */

#undef __INPUT_STR_LEN
#undef __SHORT_STR_LEN
#undef __LONG_STR_LEN
#undef __MAX_LIST


[cerrar]

 8^)

19 Agosto, 2013, 12:38 am
Respuesta #13

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Mejorando la librería bui.h...

Al desplazar las instrucciones de entrada/salida desde el programa principal a una librería,
nos hemos visto atrapados en algunos problemas de diseño.
Nos hemos topado con efectos colaterales, un uso casi obligado de goto, y aunque no lo mencionamos antes, también hay una desprolijidad general al tener acceso "externo" hacia todos los datos de la librería.



Lo primero que vamos a reparar es la función __bui_N_ARGS(), a fin de que funcione correctamente.
Reconoce con exactitud todas las directivas de scanf() según el estándar de C99.
Si hay alguna directiva que no está en la lista, automáticamente se corta el análisis
y se retorna un valor negativo indicando la presencia de un error.
No cuenta los casos de %%, ni los casos ficticios de %*, que es lo que corresponde.

Más aún, reconoce y cuenta correctamente los casos en que hay directivas con dígitos, como %15f.
¿Cómo se hace esto?
Con algo de astucia la solución es simple: simplemente se ignoran los dígitos, "saltando" a la siguiente iteración.
Así, si el indicador "before" era true, sigue siendo true hasta el próximo caracter no-dígito, y en caso contrario sigue siendo false.

Para los casos aceptados por C99 (que denominaremos "seguros", porque sabemos qué consecuencias tienen en el programa), usaremos el enfoque de coleccionar en una constante string todos los caracteres válidos de directivas para reemplazar por un argumento real.
Si se detecta un caso de estos, se aumenta la cuenta en 1.
También usaremos otra constante string para las directivas que no reemplazan por argumentos reales. Si se detecta un caso de estos, no se hace nada.

Si en cambio hay un caso no contemplado, la solución que adoptaremos es drástica: informamos un error y retornamos inmediatamente, terminando la función ahí.

Para saber si un caracter está o no en una lista de caracteres, usaremos una función que llamaremos char_in_str(), que es ésta:


/* Buscar un caracter en una cadena */
bool char_in_str(char c, char* s) {
   for ( ; *s; s++)
      if (c == *s)
         return true; /* c "pertenece" a s */
   /* c "no pertenece" a s */   
   return false;     
}


El caso %% es especial y lo tratamos directamente en el algoritmo.
Si "antes" ya había un '%', y hallamos ahora otro consecutivo,
entonces quiere decir que estamos ante el caso especial %%,
y cancelamos el estado del flag "before" poniéndolo a false.
Obviamente, no aumentamos el contador.

Nuestra función quedaría así:

(función __bui_N_ARGS():)

#define SCANF_SAFE_ARG_SET_C99 "hljztLdiouxaefgc[pAEFGXn0123456789"
#define SCANF_SAFE_SPE_SET_C99 "*"
#define SCANF_SAFE_DIGITS      "0123456789"

/* Indicador de que se halló una directiva no válida en la cadena de formato */
#define BUI_FMT_NOT_VALID -1 /* Debe ser < 0 */

/* El entero retornado por __bui_N_ARGS() es: *(
/* n >= 0: Se hallaron n directivas válidas (C99) para argumentos reales.   */
/* n < 0:  Error: hay directivas no reconocidas.                            */
/* Nota adicional: Las directivas que contienen dígitos antepuesto ("%20f") */
/* son reconocidas correctamente. */
/* Nota ténica: */
/* Los casos "%digitos%" son erróneos en C99 (ver sección 7.19.6.2.12).     */
/* pero al mismo tiempo son reconocidos inexactamente por __bui_N_ARGS().   */
/* El resultado es un programa erróneo en cualquier caso, aunque            */
/* la "semántica" para este caso de sscanf() y BUI_SCANF() no coincidirá.   */
int __bui_N_ARGS(char *s) {
    int n;
    bool before = false;
   
    for (n = 0; *s; s++)
      /* n == 0 ---> before == false */
      /* n > 0  --->                                              */
      /*     [ (último caracter leído no-dígito de s) == '%'      */
      /*               <----> before == true ]                    */
      if (*s == '%')
        /* Recordar que se ha encontrado un signo '%' en esta posición, */
        /* pero no tomar ninguna acción.                                */
        /* Si antes ya había un '%', es que estamos ante el caso %%,    */
        /* y entonces se debe "cancelar" el estado del flag "before".   */
        /* Si no, registramos la aparición de '%' como true,            */
        /* para ser analizado en la siguiente iteración.                */
        before = ( (before)? false: true );
      else {
        /* El caracter actual no es '%' */   
        if (before)
          /* *(s-1) == '%' (el caracter previo era un '%')          */
          /* Directiva % detectada.                                 */
          if (char_in_str(*s, SCANF_SAFE_DIGITS))
             /* Si se encuentra un dígito, mejor ignorarlo,                 */
             /* y seguir buscando el próximo caracter que no sea un dígito. */
/* CONTINUE */
             continue;
             /* before == true */
             /*     ---> Directivas con dígitos se reconocen correctamente. */
             
          else if (char_in_str(*s, SCANF_SAFE_ARG_SET_C99))
             /* La directiva % hallada corresponde a un caso "seguro",  */
             /* que además corresponde a un argumento real.             */
             /* ---> entonces incrementar el contador.                  */
             n++;
          else if (char_in_str(*s, SCANF_SAFE_SPE_SET_C99))
             /* La directiva % hallada corresponde a un caso "seguro",  */
             /* pero que no corresponde a un argumento real.            */
             ; /* Nada */
          else
             /* Se encontró una directiva desconocida. */
             /* Se termina abruptamente la función y retorna error. */
/* RETURN */
             return BUI_FMT_NOT_VALID; /* < 0 */
        else /* if(before) */
          ;
                   
        before = false;
        /* Se registra para la iteración siguiente */
        /* que el caracter actual no es un '%'     */
      }
    /* n == número de directivas % halladas en s.                        */
    /* Sólo se cuentan casos que efectivamente se asignan a argumentos,  */
    /* de los tipos especificados por el estándar C99.                   */
    /* No se cuentan los casos de %%, %*.                                */
           
    return n;         
}

[cerrar]

Hay un caso intrincado que puede generar dudas, y es el siguiente:

¿Qué pasa cuando ponemos la cadena de formato "%234%f"?

Nuestra función ignora los dígitos, así que considera que es análoga a "%%f", y por lo tanto estamos ante la directiva especial %%, y no ante %f.
Así que en este caso el contador no se incrementa.

¿Es correcto que esto ocurra? ¿O es un error?
Si estudiamos la definición de la función scanf() y sus dichosas cadenas de formato,
veremos que "%234%f" en realidad es una cadena de formato errónea.
Su significado no es análogo a "%%f", sino a algo "erróneo" seguido de "%f".

El estándar es claro en esto:
Citar
The complete conversion specification shall be %%.

En este caso lo único que podemos asegurar, según interpretamos del estándar C99,
es que se trata de un caso "no válido", y el resultado es indefinido: el estándar no asegura ningún comportamiento concreto a este caso.

Dado que es un caso no válido, no tendríamos obligación de remediarlo.
Sin embargo, es una nota técnica interesante el notar que nuestra función es inconsecuente con este caso, en el sentido de que no hace el reconocimiento sintáctico exacto, como "debiera ser".

Si bien tanto para sscanf() como para __bui_N_ARGS() se trata de un caso erróneo,
decimos que la semántica de sscanf() y BUI_SCANF() en ambos casos ya no coincide.
Es un detalle fino, que en alguna futura versión sería bueno corregir,
para que la semántica de ambas sea análoga.



Al final del programa agregamos nuevas "undefiniciones":


#undef SCANF_SAFE_ARG_SET_C99
#undef SCANF_SAFE_SPE_SET_C99
#undef SCANF_SAFE_DIGITS
#undef BUI_FMT_NOT_VALID


Además el párrafo de "Precauciones" en los comentarios sobre la macro BUI_SCANF()
ahora dice así:


/* Precauciones:
/* =============
/*      La cadena de formato FMT sólo reconoce directivas de C99.
/*      Opciones adicionales o de C11 y ss. no son reconocidas.
/* */




Adicionalmente, ahora podemos reconocer los casos de cadenas de formato erróneas.
Como esto es un error del programador antes que del usuario,
el mensaje de error lo provee directamente la librería, e intenta "defenderse" tanto como puede,
saltando tan afuera como se le permita (con goto TERMINATION_LABEL;) e informando en bui_input.error_state que ha habido un error.

La idea aquí es que el programador controla adecuadamente, desde la rutina principal,
los casos en que hay un error de usuario, evitando llegar al punto de "escape" de la etiqueta TERMINATION_LABEL.
Si se llega a ese punto con una señal de error, es que algo más ha ocurrido: en este caso un error en la cadena de formato.
Además aparece impreso en pantalla un mensaje, que será este:

Fatal error: format string is wrong.

Lo pongo en inglés para darle más efecto robótico.

Las líneas concretas dicen esto:


       int __n_args = __bui_N_ARGS(FMT);                             \
       if (__n_args < 0) {                                           \
          printf("Fatal error: format string is wrong.\n");          \
          bui_input.error_state = true;                              \
          goto TERMINATION_LABEL;                                    \
       }                                                             \
       bui_input.error_state = (bui_input.errno < __n_args);\


Vemos que tenemos que usar una variable temporal auxiliar __n_args,
cuya "duración" es sólo durante la existencia del bloque demarcado por las llaves.
(Ahora por fin vemos una utilidad de esas dichosas llaves).

La macro completa está aquí:

(macro BUI_SCANF() modificada:)

#define BUI_SCANF(REQ_MSG,                                        \
                  TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, \
                  FMT, ...) {                                     \
       /* [#] typedef(REQ_MSG) == (char*)                         */ \
       bui_gets(REQ_MSG);                                            \
       /* Una línea de datos entrada por teclado ha sido guardada */ \
       /* en bui_input.buffer.                                    */ \
       /* [#] typedef(FMT) == const char*                         */ \
       /* [#] __VA_ARGS__  == lista de punteros a variables       */ \
       bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__); \
       /* bui_input.errno: contiene valor de significado          */ \
       /*                  equivalente al que retornaría sscanf() */ \
       /* __bui_N_ARGS(FMT) == número de directivas en FMT        */ \
       /*     (no da el número exacto de argumentos esperados...) */ \
       int __n_args = __bui_N_ARGS(FMT);                             \
       if (__n_args < 0) {                                           \
          printf("Fatal error: format string is wrong.\n");          \
          bui_input.error_state = true;                              \
          goto TERMINATION_LABEL;                                    \
       }                                                             \
       bui_input.error_state = (bui_input.errno < __n_args);\
       /* [#] typedef(TERMINATION_FUNC) == (bool) (char*)         */ \
       /* [#] TERMINATION_LABEL: es una etiqueta válida.          */ \
       /* [#] typedef(ERROR_MSG) == (char*)                       */ \
       if (bui_input.error_state)    \
          if (TERMINATION_FUNC (bui_input.buffer))        \
              goto TERMINATION_LABEL;                     \
          else \
              printf(ERROR_MSG);                          \
       else;   \
    }


[cerrar]



A esta altura parece obvio que la macro BUI_SCANF() se está complicando demasiado.

Por ahora dejamos esto así, y buscaremos mejoras de estilo a partir de los siguientes posts.



19 Agosto, 2013, 04:19 am
Respuesta #14

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Me cansé de los gotos hacia quién sabe dónde de la macro BUI_SCANF().
Una macro dedicada a procesar datos del teclado no debiera preocuparse del destino del resto del programa.
Más bien es preferible que deje registrado todos los posibles errores en alguna parte (en la struct anónima bui_input, por ejemplo), y que el programador se encargue de tomar las decisiones pertinentes.

Vamos a cambiar dicha estructura, para considerar varios tipos de errores:


struct {
    char buffer[__INPUT_STR_LEN];
    int errno;
    bool userinputerr;
    bool fatalerr;
} bui_input = { .userinputerr = false; .fatalerr = false; };


El campo error_state lo he cambiado a userinputerr.
Es que su significado será sólo "el usuario ha ingresado datos erróneos".
En cambio, el campo fatalerr significará "hay un error fatal", que normalmente indicará un error del programador, o alguna otra situación irregular durante la ejecución del programa.



Pasar parámetros a una macro... ¡sólo del tipo especificado!

Ahora vamos a la macro BUI_SCANF(), con la intención de cambiarla por completo.

1ero que nada, vamos a asegurarnos que el tipo de datos que pasamos como parámetros a la macro realmente coincide con lo que nos gusta.
Para ello, definiremos instancias de variables locales al bloque interno de la macro BUI_SCANF(),
aprovecharemos las reglas del compilador para detectar tipos erróneos.

Lo único lamentable de este enfoque es que debemos duplicar variables ya existentes.
(En el caso de strings no se duplica toda la cadena de caracteres, sino sólo el puntero que apunta a ella).
Sin embargo, esto no es muy diferente de lo que ocurre cuando se llama a una función que realiza copias locales de los parámetros que se le han pasado.


       char *__req_msg = REQ_MSG;                 \
       /* [--->] typedef(REQ_MSG) == (char*) */   \
       char *__error_msg = ERROR_MSG;             \
       /* [--->] typedef(ERROR_MSG) == (char*) */ \
       char *__fmt = FMT;                         \
       /* [--->] typedef(FMT) == (char*) */       \
       int (*__spfunc)(char*) = SPFUNC;          \
       /* [--->] typedef(SPFUNC) == int (función) (char*) */   \


Cuando el programador intente pasar parámetros irresponsables o erróneos a la macro,
el compilador los rechazará sin problemas.

Nota: He eliminado el parámetro TERMINATION_FUNC.
En su lugar voy a poner otro que diga SPFUNC,
que tiene otro significado: "función especial".

Esa función admite una string (char*) como parámetro, y retorna un int.
Si no se pasa una función con el formato apropiado, el programa no compilará, lo cual nos da un gran alivio,
ya que estamos controlando las arbitrariedades intrínsecas del uso de macros.


La "función especial" ahora retornará información más rica que un simple true/false,
ya que se usará para tener en cuenta toda una lista de posibles entradas especiales que el usuario pueda elegir, es decir: ¡comandos!

Estos comandos habrán de estar referenciados (como constantes int) en alguna parte. ¿En dónde conviene? ¿En la librería bui.h, o en el programa principal?
Lo adecuado, creo yo, es que se definan en el programa principal.

La macro BUI_SCANF() solamente tendrá en cuenta si el resultado de esa "función especial" es 0 o no.
Con el valor 0 vamos a significar: "no ha ocurrido nada especial", es decir, el usuario ha entrado datos tal como se le pedían, sin intentar ningún "comando extraño".

Esto debe estar documentado, para que el programador pueda diseñar funciones "especiales" que trabajen armoniosamente con BUI_SCANF().

A la estructura bui_input le agregaremos el campo special,
que guardará el resultado de la llamada a la función "especial" __spfunc().

Así que ahora nuestra macro tendrá un comportamiento más lógico:

(1ro) Descarta de plano los parámetros de tipo incorrecto.
(2do) Verifica si la cadena de formato es correcta. Si es errónea, da un mensaje de error fatal, registra el error en bui_input.fatalerr, y no hace nada más.
(3ro) Si no, lee datos desde el teclado: exactamente una línea hasta que el usuario presiona Enter.
(4to) Verifica si el usuario ha introducido algún comando "especial", lo cual equivale a un valor no nulo. En ese caso registra el hecho en bui_input.special, y no hace nada más.
(5to) Si no, se sobreentiende que el usario ha intentado ingresar datos de manera normal.
     Se verifica si los datos ingresados son correctos.
(6to) Si no son datos correctos, se imprime en pantalla el mensaje de error que está en la string __msg_err.
(7mo) Si los datos ingresados por el usuario son correctos, no se hace nada, pero queda registrado que no hubo errores en bui_input.userinputerr.

En todos los casos, tras terminar el bloque de la macro BUI_SCANF()
se han actualizado correctamente todos los campos booleanos de bui_input,
para que el programa principal pueda tomar decisiones en base a ellos.

(macro BUI_SCANF(), nueva versión)


#define BUI_SCANF(REQ_MSG, ERROR_MSG, SPFUNC, FMT, ...) { \
       char *__req_msg = REQ_MSG;                 \
       /* [--->] typedef(REQ_MSG) == (char*) */   \
       char *__error_msg = ERROR_MSG;             \
       /* [--->] typedef(ERROR_MSG) == (char*) */ \
       char *__fmt = FMT;                         \
       /* [--->] typedef(FMT) == (char*) */       \
       bool (*__spfunc)(char*) = SPFUNC;          \
       /* [--->] typedef(SPFUNC) == bool (función) (char*) */   \
       \
       int __n_args = __bui_N_ARGS(__fmt);                           \
       /* __bui_N_ARGS(__fmt) == número de directivas "reales" en __fmt */ \
       bui_input.fatalerr = (__n_args < 0);                          \
       if (bui_input.fatalerr)                                       \
           printf("Fatal error: format string is wrong.\n");         \
       else { \
           bui_gets(__req_msg);                                             \
           /* Una línea de datos de entrada por teclado ha sido guardada */ \
           /* en bui_input.buffer.                                       */ \
           bui_input.special = __spfunc(bui_input.buffer);                  \
           if (bui_input.special == BUI_NOT_SPECIAL) {                                   \
               /* Caso "normal" de ingreso de datos. */                     \
               /* [#] __VA_ARGS__  == lista de punteros a variables   */    \
               bui_input.errno = sscanf(bui_input.buffer, __fmt, __VA_ARGS__);\
               /* bui_input.errno: entero de significado análogo al      */ \
               /*                  valor de retorno de sscanf()          */ \
               bui_input.userinputerr = (bui_input.errno < __n_args);       \
               if (bui_input.userinputerr)                        \
                      printf(__error_msg);                          \
          } /* if(bui_input.special == 0) */ \
          else \
             ; /* No se hace nada si bui_input.special != 0 */ \
       } /* else */ \
    }

[cerrar]

Desde la rutina principal hay que realizar verificaciones en un orden específico,
que es el que explicaremos en comentarios como los que siguen:


/* if(bui_input.fatalerr)
/*   /* Finalizar el programa */
/* else if (bui_input.special)
/*       switch(bui_input.special) {
/*           case 1: /* ejecutar rutina 1 */
/*           break;
/*           case 2: /* ejecutar rutina 2 */
/*           break;
/*           /* ... ^/
/*           case N: /* ejecutar rutina N */
/*           break;
/*       }
/* else if (bui_input.userinputerr)
/*     /* Realizar acción asociada a ingreso de datos erróneos del usuario */
/* else
/*    /* Entrada de datos "normal", compatible con la cadena de formato FMT */
/*    /* Realizar acciones con los datos ingresados por el usuario */




La parte de comentarios que explican el uso de BUI_SCANF() ha cambiado,
y también hemos cambiado los comentarios de la estructura bui_input.
Además, ahora se me ocurrió mejor dejar inicializados todos los campos de bui_input.

La librería en su nueva versión queda ahora así:

(bui.h versión 1.23)
bui0123.h:


/* ========================================================================= */
/* BUI.H 1.21 (Basic User Interface)
/*
/* Esta librería da una interface básica para presentar programas simples en C
/*
/* 2013/ago/18
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
/*
/* Esta librería provee una interface sencilla y sólida
/* para intercambio de información con el usuario por la E/S estándar.
/*
/* Hay una macro principal BUI_SCANF(), que reemplaza a la función scanf(),
/* y se encarga de gestionar la entrada por teclado de forma segura,
/* y gestionar situaciones de error de forma genérica.
/*
/* La estructura bui{} contiene campos de tipo char[], de longitud fija,
/* que pueden usarse para guardar en forma permanente
/* los mensajes e informaciones que necesita el programa
/* (nombre, vesión, autor, etc.; comentarios, ayudas, errores, mensajes, etc.)
/*
/* La estructura bui_input{} contiene campos
/* que controlan la entrada por teclado, y contienen señales de error.
/*
/* void bui_set_string(char *, char *):
/*    Función que se usa para asignar valores a los campos de bui{}.
/*
/* void bui_show_program_info(void):
/*    Función que muestre información básica del programa (contenida en bui{}).
/*
/* void bui_print_list(char (*list)[__LONG_STR_LEN]):
/*    Función que se usa para mostrar datos con formato de lista en bui{}.
/*
/* bool blank(char* ):
/*    Función de propósito general que indica si
/*    todos los caracteres de una cadena son blancos,
/*    siguiendo estrictamente las especificaciones
/*    de la función estándar isspace(),
/*    de la librería estándar ctype.h, según el estándar C99.
/*
/* ========================================================================= */

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>

/* */
/* struct { ... } bui;
/* ===================
/*
/* Es una estructura anónima que contiene strings.
/* Las strings de longitud "corta" se usan para información básica del programa.
/* Las strings de longitud "larga" se usan para información más compleja.
/*
/* program_name, program_vers, program_date, program_coun, program_auth:
/*   Son strings de longitud "corta", y se refieren a:
/*   Nombre (del programa), Versión, Fecha, País, Autor.
/*
/* program_purp, program_comm, program_help,
/* program_req, program_mess, program_err:
/*   Son strings de longitud "larga", y se refieren a:
/*   Propósito (del programa), Comentarios, Ayuda,
/*   Solicitudes al usuario (requests), Mensajes al usuario, Mensajes de error.
/*
/* En programas más complejos pueden requerirse varios mensajes distintos
/* del tipo de los indicados, y por eso se añaden listas de mensajes con
/* la misma temática, por si hicieran falta:
/*
/* program_comm_, program_help_,
/* program_req_, program_mess_, program_err_:
/*   Cada uno de ellos es un array de __MAX_LIST (16) strings "largas", para
/*   añadir distintos tipos de comentarios, ayudas, mensajes, errores, etc.
/*
/* Las macros constantes __SHORT_STR_LEN, __LONG_STR_LEN, __MAX_LIST,
/* albergan el tamaño prefijado de todas estas strings.
/* Sus valores no son accesibles desde el "exterior",
/* porque se "undefinen" al final del archivo.
/*
/* */

#define __SHORT_STR_LEN   32  /* Longitud string corta. */
#define  __LONG_STR_LEN 1024  /* Longitud string larga. */
#define __MAX_LIST        16  /* Longitud de listas de varios ítems en bui.h */

struct {
    char
      program_name[__SHORT_STR_LEN],
      program_vers[__SHORT_STR_LEN],
      program_date[__SHORT_STR_LEN],
      program_coun[__SHORT_STR_LEN],
      program_auth[__SHORT_STR_LEN],

      program_purp[__LONG_STR_LEN],
      program_comm[__LONG_STR_LEN],
      program_comm_[__MAX_LIST][__LONG_STR_LEN],
      program_help[__LONG_STR_LEN],
      program_help_[__MAX_LIST][__LONG_STR_LEN],
      program_req[__LONG_STR_LEN],
      program_req_[__MAX_LIST][__LONG_STR_LEN],
      program_mess[__LONG_STR_LEN],
      program_mess_[__MAX_LIST][__LONG_STR_LEN],
      program_err[__LONG_STR_LEN],
      program_err_[__MAX_LIST][__LONG_STR_LEN];
} bui;

/* */
/* struct { ... } bui_input;
/* =========================
/*
/* Es una estructura anónima que sirve para gestionar la entrada estándar.
/* Sus campos son:
/*
/*    char buffer[]:
/*          Un array de caracteres para albertar los datos de entrada.
/*    bool fatalerr:
/*          Vale true si en la última operación de entrada con BUI_SCANF()
/*          se ha utilizado una cadena de formato errónea.
/*          No todas las cadenas de formato erróneas producen "true".
/*          En general es un error del programador, y no del usuario.
/*    int special:
/*          Contiene un entero que significa algún tipo de comando "especial"
/*          que el usuario ha introducido con el teclado.
/*          Si el valor es BUI_NOT_SPECIAL ( == 0), quiere decir que
/*          el usuario ha intentado ingresar datos "normales".
/*    int errno:
/*          Contiene el resultado de la operación de entrada,
/*          el cual coincide con el que generaría sscanf(),
/*          siempre que su valor sea modificado por las operaciones "internas"
/*          de éste archivo de librería.
/*    bool userinputerr:
/*          Es un "flag" (banderín) que informa si la última operación
/*          de entrada ha tenido errores (true) o ha sido exitosa (false).
/*          Para ser consecuentes con este significado,
/*          se inicializa su valor a "false" al principio del programa.
/*
/* La longitud de la cadena "buffer" es __INPUT_STR_LEN,
/* que es una macro constante inaccesible desde el "exterior",
/* pues se "undefine" al final del archivo.
/* Tiene un valor de 130, suficiente para la consola típica de 128 caracteres,
/* más 1 caracter nulo que agrega al final la función gets().
/* Si se va a correr el programa en un entorno donde la consola admita entradas
/* más extensas, este valor no sería suficiente.
/* (Mas, sería preferible recortar la entrada, antes que agrandar el buffer.)
/*
/* */

#define __INPUT_STR_LEN  130  /* Longitud string datos entrados por teclado. */
#define BUI_NOT_SPECIAL 0     /* Debe ser siempre 0 */

struct {
    char buffer[__INPUT_STR_LEN];
    bool fatalerr;
    int special;
    int  errno;
    bool userinputerr;
} bui_input =
   { .buffer  = "",
     .fatalerr = false,
     .special  = BUI_NOT_SPECIAL,
     .errno    = 0,
     .userinputerr = false
   };

/* bui_set_string(char* dest, char* src):
/*     Copia la cadena src en la cadena dest.
/*     Su propósito es asignar valores a las strings de la estructura bui{}.
/*     Ejemplo:
/*       bui_set_string(bui.program_comm, "Este programa calcula el M.C.D.\n");
/* */
void bui_set_string(char* restrict, const char* restrict);

/* bui_show_program_info():
/*     Muestra en pantalla la información básica del programa,
/*     con un formato predefinido:
/*
/* NOMBRE VERSIÓN
/* FECHA PAÍS
/* AUTOR
/*
/* Los datos consignados son leídos directamente de los campos de gui{}:
/*    program_name, program_vers, program_date, program_coun, program_auth.
/*
/* Al final agrega una línea en blanco como separador.
/* */
void bui_show_program_info(void);

/* bui_print_list():
/*     Muestra en pantalla todas las strings de un array de strings,
/*     tal que cada string tiene longitud __LONG_STR_LEN.
/*     Las muestra en secuencia según su índice de array, de 0 a __MAX_LIST.
/*     Agrega un caracter fin_de_línea \n al final de cada ítem de la lista.
/*     Si un ítem es una cadena vacía (""), no hace nada.
/* */
void bui_print_list(char (*list)[__LONG_STR_LEN]);

/* Macro:
/* BUI_SCANF(REQ_MSG, ERROR_MSG, SPFUNC, FMT, ...) 
/*
/* Macro para la entrada de datos, al estilo de scanf() o sscanf().
/* (Es decir, acepta un número variable de parámetros).
/*
/* REQ_MSG:
/*    Es una string (char*) que contiene un mensaje para dar al usuario
/*    con una solicitud de que ingrese datos de cierta clase.
/*    Si no se ingresa un (char*) el compilador lo detectará.
/* ERROR_MSG:
/*    Es una string (char*) que contiene un mensaje de error,
/*    el cual se mostrará al usuario en caso de ingreso erróneo de datos.
/*    Si no se ingresa un (char*) el compilador lo detectará.
/* SPFUNC:
/*    Es el nombre de una función del tipo: int (* ) (char*) (o compatible...).
/*    Es decir, una función que acepta un char* como único parámetro,
/*    y que retorna un int.
/*    Si se pasan otros tipos de objetos o de funciones incompatibles,
/*    el compilador lo detectará.
/*    Se utiliza para detectar comandos especiales ingresados por el usuario.
/*    Cada comando tendrá asociado un número entero distinto de 0,
/*    y el número asignado dependerá de la función SPFUNC,
/*    que es proveída por el programador.
/* FMT:
/*    Es una cadena de formato que funciona igual que las de scanf().
/*    (Sólo el caso de dígitos interpuestos entre un par de % %
/^     fuciona de modo diferente. Sin embargo, este caso es erróneo tanto
/*     para sscanf como para BUI_SCANF() ).
/* ...:
/*    Número variable parámetros, en donde se han de consignar
/*    las direcciones de memoria de las variables a ser asignadas durante
/*    el proceso de lectura de datos
/*    (según las directivas de tipos de datos consignados en FMT).
/*
/* Para usar la macro BUI_SCANF() se deben consignar todos los parámetros
/* arriba explicados, y además al menos 1 parámetro más en la lista variable.
/* Al principio la macro define variables de los tipos deseados,
/* e intenta asignarles directamente los parámetros.
/* Si esto no fuera posible, el programa no compilará.
/* En el resto de la macro se usan las variables, pues tienen tipos concretos.
/*
/* Se analiza la cadena de formato FMT, y si contiene un error se informa
/* en el campo bui_input.fatalerr, terminando la macro inmediatamente.
/*
/* Si no, se lee una línea de la entrada estándar (hasta el 1er fin de línea).
/* Estos caracteres se guardan en bui_input.buffer.
/*
/* Con la función SPFUNC() (pasada como parámetro por el programador),
/* se analiza la línea de entrada, y se intenta detectar un comando "especial".
/* En caso afirmativo (un valor no nulo), esto se registra en la variable
/* bui_input.special, y se termina la macro inmediatamente.
/*
/* Luego se "releen" los caracteres del buffer, y se intenta convertirlos
/* en valores apropiados, según indique la cadena de formato FMT,
/* pasando estos valores a la lista variable de parámetros.
/* El método en que se realiza esta asignación es idéntico al de sscanf().
/* El resultado de esta operación es un entero (int),
/* igual al valor que generaría una llamada a sscanf().
/* Este valor queda guardado en:
/*         bui_input.errno
/* Se calcula la cantidad de asignaciones esperadas
/* (esto se logra calculando la cantidad de caracteres '%' de FMT
/* que realmente se usarán para asignar valores a variables).
/* El cálculo se hace con la función:
/*        int __bui_N_ARGS(char* );
/* Se compara este valor con el almacenado en bui_input.errno,
/* y el resultado se guarda como un valor bool en
/*        bui_input.error_state
/* Su valor es "true" cuando la comparación de los dos valores falla.
/* Esto es indicativo de "error" de lectura: significa que el usuario
/* ha ingresado datos erróneos, y esto quedar consignado en
/* la variable bui_input.userinputerr.
/* En ese caso se envía al usuario el mensaje de error ERROR_MSG.
/*
/* La rutina que llamó a la macro BUI_SCANF() tiene que verificar
/* los campos de bui_input, y actuar en consecuencia.
/* El modo de hacer esto tiene que ser el siguiente:
/*
/* if(bui_input.fatalerr)
/*   /* Finalizar el programa */
/* else if (bui_input.special)
/*       switch(bui_input.special) {
/*           case 1: /* ejecutar rutina 1 */
/*           break;
/*           case 2: /* ejecutar rutina 2 */
/*           break;
/*           /* ... ^/
/*           case N: /* ejecutar rutina N */
/*           break;
/*       }
/* else if (bui_input.userinputerr)
/*     /* Realizar acción asociada a ingreso de datos erróneos del usuario */
/* else
/*    /* Entrada de datos "normal", compatible con la cadena de formato FMT */
/*    /* Realizar acciones con los datos ingresados por el usuario */
/*
/* Ejemplo de uso:
/*
/* #include bui0120.h
/*
/* int main(void) {
/*     float x, y, z;
/*
/*     BUI_SCANF("Ingrese 3 números: ", "Error! Intente otra vez!\n",
                 blank,
/*               "%f %f %f", &x, &y, &z
/*     );
/*
/*     if(bui_input.fatalerr)
/*     else if (bui_input.special)
/*          switch(bui_input.special) {
/*              case 1: return 0; /* FIN DEL PROGRAMA */
/*              break;
/*          }
/*     else if (bui_input.userinputerr)
/*         printf("No puedo calcular nada con esa actitud tuya!! :( \n\n");
/*     else
/*         printf("Datos correctos!\nSu promedio es: %f\n\n", (x+y+z)/3);
/*
/*     return 0;   
/* }
/*
/* Precauciones:
/* =============
/*      La cadena de formato FMT sólo reconoce directivas de C99.
/*      Opciones adicionales o de C11 y ss. no son reconocidas.
/* */

/* blank():
/*     Decide si la cadena de caracteres tomada como parámetro
/*     contiene sólo caracteres "blancos" (y retorna true), o no (false).
/*     El significado de "caracter blanco" es el mismo que
/*     interpreta isspace() de la librería estándar ctype.h.
/* */
bool blank(char* );


/* ========================================================================= */
/* Implementación:
/* */

void bui_show_program_info(void) {
    printf("%s %s\n%s %s\n%s\n\n",
       bui.program_name, bui.program_vers,
       bui.program_date, bui.program_coun,
       bui.program_auth,
       bui.program_comm
    );
/* Los datos se muestran con el formato:
/* ----------------------------------------- */
/* NOMBRE VERSIÓN
/* FECHA PAÍS
/* AUTOR
/*
/* ----------------------------------------- */
}

void bui_print_list(char (*list)[__LONG_STR_LEN]) {
    for (int i = 0; i < __MAX_LIST; i++)
      if (list[i][0])
         /* list[i] == "" */
         /* Como puts() agrega un fin de línea,                       */
         /* se desea que este efecto no ocurra si la cadena es vacía: */
         puts(list[i]);
}

void bui_set_string(char* restrict dest, const char* restrict src) {
    /* Copia src en dest */
    /* Las direcciones de las strings originales no son alteradas. */
    /* Sin embargo se modifica el contenido de dest.               */
    /* (No se cambia el contenido de src).                         */
    /* Se realiza la asignación caracter a caracter, */
    /* luego se compara el valor asignado contra 0,  */
    /* en cuyo caso el proceso termina.              */
    /* Si no termina, se avanza una posición de memoria en cada string. */
    for( ; (*dest = *src) != '\0'; src++, dest++)
      ;
}
/* ---> OUT: dest == src, strlen(dest) == strlen(src) */

/* La siguiente función tiene ciertos efectos colaterales: */
/* [*] modifica bui_input.buffer                           */
/*                                                         */
/* [!] El uso de gets() no es seguro: */
/* [*] permite al usuario ingresar cadenas de longitud mayor que el buffer, */
/*     causando errores en tiempo de ejecución.                             */
void bui_gets(char *req) {
    printf("%s", req);
    gets(bui_input.buffer); /* Unsafe... */
}


/* Conjunto de directivas de reemplazo efectivo por argumentos válidos      */
/* en funciones del estilo de scanf(), en la librería stdio.h, de C99 o ss. */

/* Buscar un caracter en una cadena */
bool char_in_str(char c, char* s) {
   for ( ; *s; s++)
      if (c == *s)
         return true; /* c "pertenece" a s */
   /* c "no pertenece" a s */   
   return false;     
}

#define SCANF_SAFE_ARG_SET_C99 "hljztLdiouxaefgc[pAEFGXn0123456789"
#define SCANF_SAFE_SPE_SET_C99 "*"
#define SCANF_SAFE_DIGITS      "0123456789"

/* Indicador de que se halló una directiva no válida en la cadena de formato */
#define BUI_FMT_NOT_VALID -1 /* Debe ser < 0 */

/* El entero retornado por __bui_N_ARGS() es: *(
/* n >= 0: Se hallaron n directivas válidas (C99) para argumentos reales.   */
/* n < 0:  Error: hay directivas no reconocidas.                            */
/* Nota adicional: Las directivas que contienen dígitos antepuesto ("%20f") */
/* son reconocidas correctamente. */
/* Nota ténica: */
/* Los casos "%digitos%" son erróneos en C99 (ver sección 7.19.6.2.12).     */
/* pero al mismo tiempo son reconocidos inexactamente por __bui_N_ARGS().   */
/* El resultado es un programa erróneo en cualquier caso, aunque            */
/* la "semántica" para este caso de sscanf() y BUI_SCANF() no coincidirá.   */
int __bui_N_ARGS(char *s) {
    int n;
    bool before = false;
   
    for (n = 0; *s; s++)
      /* n == 0 ---> before == false */
      /* n > 0  --->                                              */
      /*     [ (último caracter leído no-dígito de s) == '%'      */
      /*               <----> before == true ]                    */
      if (*s == '%')
        /* Recordar que se ha encontrado un signo '%' en esta posición, */
        /* pero no tomar ninguna acción.                                */
        /* Si antes ya había un '%', es que estamos ante el caso %%,    */
        /* y entonces se debe "cancelar" el estado del flag "before".   */
        /* Si no, registramos la aparición de '%' como true,            */
        /* para ser analizado en la siguiente iteración.                */
        before = ( (before)? false: true );
      else {
        /* El caracter actual no es '%' */   
        if (before)
          /* *(s-1) == '%' (el caracter previo era un '%')          */
          /* Directiva % detectada.                                 */
          if (char_in_str(*s, SCANF_SAFE_DIGITS))
             /* Si se encuentra un dígito, mejor ignorarlo,                 */
             /* y seguir buscando el próximo caracter que no sea un dígito. */
/* CONTINUE */
             continue;
             /* before == true */
             /*     ---> Directivas con dígitos se reconocen correctamente. */
             
          else if (char_in_str(*s, SCANF_SAFE_ARG_SET_C99))
             /* La directiva % hallada corresponde a un caso "seguro",  */
             /* que además corresponde a un argumento real.             */
             /* ---> entonces incrementar el contador.                  */
             n++;
          else if (char_in_str(*s, SCANF_SAFE_SPE_SET_C99))
             /* La directiva % hallada corresponde a un caso "seguro",  */
             /* pero que no corresponde a un argumento real.            */
             ; /* Nada */
          else
             /* Se encontró una directiva desconocida. */
             /* Se termina abruptamente la función y retorna error. */
/* RETURN */
             return BUI_FMT_NOT_VALID; /* < 0 */
        else /* if(before) */
          ;
                   
        before = false;
        /* Se registra para la iteración siguiente */
        /* que el caracter actual no es un '%'     */
      }
    /* n == número de directivas % halladas en s.                        */
    /* Sólo se cuentan casos que efectivamente se asignan a argumentos,  */
    /* de los tipos especificados por el estándar C99.                   */
    /* No se cuentan los casos de %%, %*.                                */
           
    return n;         
}

bool blank(char *s) {
    for ( ; *s; ++s)
       if (!isspace(*s))
          /* Se ha encontrado un caracter que no es blanco. */
          return false;
     
    /* s es una string que sólo contiene blancos (al "estilo" isspace()) */
    return true;
}

#define BUI_SCANF(REQ_MSG, ERROR_MSG, SPFUNC, FMT, ...) { \
       char *__req_msg = REQ_MSG;                 \
       /* [--->] typedef(REQ_MSG) == (char*) */   \
       char *__error_msg = ERROR_MSG;             \
       /* [--->] typedef(ERROR_MSG) == (char*) */ \
       char *__fmt = FMT;                         \
       /* [--->] typedef(FMT) == (char*) */       \
       bool (*__spfunc)(char*) = SPFUNC;          \
       /* [--->] typedef(SPFUNC) == bool (función) (char*) */   \
       \
       int __n_args = __bui_N_ARGS(__fmt);                           \
       /* __bui_N_ARGS(__fmt) == número de directivas "reales" en __fmt */ \
       bui_input.fatalerr = (__n_args < 0);                          \
       if (bui_input.fatalerr)                                       \
           printf("Fatal error: format string is wrong.\n");         \
       else { \
           bui_gets(__req_msg);                                             \
           /* Una línea de datos de entrada por teclado ha sido guardada */ \
           /* en bui_input.buffer.                                       */ \
           bui_input.special = __spfunc(bui_input.buffer);                  \
           if (bui_input.special == BUI_NOT_SPECIAL) {                                   \
               /* Caso "normal" de ingreso de datos. */                     \
               /* [#] __VA_ARGS__  == lista de punteros a variables   */    \
               bui_input.errno = sscanf(bui_input.buffer, __fmt, __VA_ARGS__);\
               /* bui_input.errno: entero de significado análogo al      */ \
               /*                  valor de retorno de sscanf()          */ \
               bui_input.userinputerr = (bui_input.errno < __n_args);       \
               if (bui_input.userinputerr)                        \
                      printf(__error_msg);                          \
          } /* if(bui_input.special == 0) */ \
          else \
             ; /* No se hace nada si bui_input.special != 0 */ \
       } /* else */ \
    }

/* Quitamos las definiciones de los símbolos definidos en la librería */
/* para que queden inaccesibles desde archivos externos. */

#undef __INPUT_STR_LEN
#undef __SHORT_STR_LEN
#undef __LONG_STR_LEN
#undef __MAX_LIST
#undef SCANF_SAFE_ARG_SET_C99
#undef SCANF_SAFE_SPE_SET_C99
#undef SCANF_SAFE_DIGITS
#undef BUI_FMT_NOT_VALID


[cerrar]


19 Agosto, 2013, 04:28 am
Respuesta #15

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
El programa del máximo común divisor (que ya no me acuerdo qué significaba eso)
ahora hace caso a las recomendaciones de los comentarios que figuran en bui.h,
y actúa en consecuencia, según los errores encontrados en la estructura bui_input.

El resultado tiene esta pinta:

(GCD 1.23)
gcd0123.c:


/* ========================================================================= */
/* GCD 1.23
/*
/* Este programa calcula el máximo común divisor de dos números enteros.
/*
/* 2013/ago/18
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
 
#include "bui0123.h"
#include "gcd0110.h"

void start(void);

int main(void) {
   start();

   do {
     int m, n;

     BUI_SCANF(bui.program_req, bui.program_err, blank, "%d %d", &m, &n);
         
     if(bui_input.fatalerr)
       return -1; /* Termina el programa en condiciones anormales */
     else if (bui_input.special)
           switch(bui_input.special) {
               case 1: return 0; /* FIN DEL PROGRAMA por orden del usuario */
               break;
           }
     else if (bui_input.userinputerr)
         continue; /* Comenzar de nuevo. */
     else {
         /* DATOS INGRESADOS NORMALES ---> acciones principales del programa */       
   
        int ans = gcd(m, n);
        printf(((ans >= 0)? "gcd(%i,%i) = %i\n\n": "gcd(0, 0) = INFINITO\n\n"),
               m, n, ans);
     }   
         
   } while (1); 
       
   return 0;
}

void start(void) {
   bui_set_string(bui.program_name, "GCD");
   bui_set_string(bui.program_vers, "01.22");
   bui_set_string(bui.program_auth, "Argentinator");
   bui_set_string(bui.program_date, "2013/Ago/18");
   bui_set_string(bui.program_coun, "www.rinconmatematico.com");

   bui_set_string(bui.program_purp,
     "Este programa calcula el M.C.D. de dos nros. enteros\n"
     "Si ambos valores son nulos, el resultado es INFINITO.\n"
   );
   bui_set_string(bui.program_comm,
     ""
   );
   bui_set_string(bui.program_help,
     ""
   );
   bui_set_string(bui.program_req,
     "Escriba dos enteros separados por un caracter blanco\n"     
     "(o sólo ENTER para terminar).\n\n"
   );
   bui_set_string(bui.program_err,
     "\nDatos no validos.\n"
     "Se requieren dos numeros enteros.\n"
     "Intente nuevamente.\n\n"   
   );
   
   bui_show_program_info();
}



[cerrar]

A pesar de todas las revoluciones internas que hemos estado haciendo,
el programa hace lo mismo que hace unos 5 o 6 versiones atrás.

Sólo estamos aprendiendo a programar con más prolijidad...  :)

19 Agosto, 2013, 06:16 am
Respuesta #16

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
La traicionera función gets()...

Hasta ahora he usado gets() para leer la entrada, en forma totalmente desvergonzada.
No es posible predecir el tamaño de los datos de entrada, causando posibles estragos no sólo en el programa, sino en todo el sistema.  :o :o :o :o

Esto se debe a que si se leen más caracteres que los que caben en el buffer utilizado,
el resultado es una sobreescritura en las posiciones aledañas de memoria, que no se sabe quién o qué las está ocupando.

gets() es una función que está totalmente "prohibida".
Usarla es un pecado informático.  >:D >:D


Necesitamos una alternativa.

La función fgets() cumple una tarea similar, salvo que lee una línea de cualquier archivo que le indiquemos.
¡Pero la entrada estándar también es un archivo! Y su nombre es stdin.

Así que, reemplazaríamos

gets(buffer);

por la sentencia:

fgets(buffer, n, stdin);

Ahí apareció un misterioso parámetro "n".
Es un número entero que indica cuántos caracteres se van a leer como máximo.
(En realidad se leen \( n - 1 \), o sea, 1 menos que el especificado).
Esto es importante porque ahora podemos poner un límite superior a la cantidad de caracteres que queremos leer.
Ajustaremos esa cantidad a la constante __INPUT_STR_LEN de nuestra librería bui.h.

Ahora tenemos un método más "seguro" para lectura de datos de la entrada estándar...

Pero hay algunos problemas nuevos que atender.
Si bien gets() lee hasta el caracter fin de línea, procede luego a descartarlo, y lo reemplaza por un caracter nulo.
En cambio fgets() no descarta el caracter fin de línea cuando lo lee.
En cualquier caso, añade luego un caracter nulo.

Este salto de línea '\n' que queda retenido en la cadena leída no es gran problema,
ya que nosotros luego hacemos una relectura con sscanf(), que hace caso omiso de los saltos de línea que cuelgan al final, ya que son datos "basura", que no influyen en la asignación de valores a los argumentos de sscanf().

No obstante, la posible presencia de un caracter fin de línea al final de la cadena
es algo que debe documentarse, para que el programador diseñe funciones del tipo que encaja en el parámetro SPFUNC de la macro BUI_SCANF(), y tiene que tener en cuenta la presencia de tales caracteres (y descartarlos elegantemente).



Pero el problema mayor ocurre cuando el buffer es demasiado pequeño, y fgets() termina de llenarlo antes de haber alcanzado el caracter fin de línea.
Esto quiere decir que los caracteres sobrantes que ha ingresado el usuario
todavía quedan aguardando en memoria hasta la próxima llamada a fgets().

El efecto de esto es que la próxima llamada a fgets() no pedirá datos al usuario, sino que los tomará directamente de la memoria, porque ahí ya había datos aguardando a ser usados.

Se presenta entonces el problema de "limpiar" el archivo de entrada estándar stdin.
El modo más claro y sencillo de hacerlo es con una función como ésta:

void flush_stdin(void) {
       while ( getchar() != '\n' )
           /* */ ;
}


Pero si invocamos esta función detrás de fgets(),
incluso en los casos en que se ha alcanzado y leído correctamente el caracter fin de línea,
la función flush_stdin() buscará otro más.

Un modo de evitar esto es analizar si el buffer contiene o no un caracter fin de línea.
Pero tenemos que analizar esto con inteligencia.
Si el buffer contiene un '\n', contiene uno solo, y puede estar ubicado en cualquier parte de la cadena.
¿Acaso nos vamos a poner a buscarlo por ahí adentro?  >:(
¿Qué tan complicado se vuelve esto de descartar un simple fin de línea?  >:(  >:( >:(

La verdad es que eso no nos interesa.
Lo que nos interesa es reconocer el caso en que un '\n' no ha sido alcanzado.
Entonces el buffer contiene todos caracteres distintos de '\n'.
Más aún, el buffer está lleno, porque si no, significaría que el fin de línea '\n' se habría alcanzado.
En este caso, el último caracter del buffer es '\0', el caracter nulo.

Supongamos que buffer tiene longitud \( N \).
Como la primer posición es 0, el último caracter tiene índice \( N-1 \).
Así que

buffer[N-1] == '\0'

En cambio

buffer[N-2] != '\0'

Y más aún:

buffer[N-2] != '\n'

Recíprocamente,
si estas últimas dos condiciones se cumple, quiere decir que el buffer está lleno,
o sea que fgets() no ha alcanzado el fin de línea.

En resumen:
no se ha alcanzado el fin de línea si y sólo si (buffer[N-2] != '\0') && (buffer[N-2] != '\n')

Así que ahora tenemos una manera correcta de limpiar la entrada estándar:


char buffer[N];
fgets(buffer, N, stdin);
if ((buffer[N-2] != '\0') && (buffer[N-2] != '\n'))
   /* No se ha alcanzado el fin de línea */
   flush_stdin();
else
  /* Sí se ha alcanzado el fin de línea: no se hace nada. */
  ;


Eso debería funcionar...
pero siempre falla algo.
¿Cuál es el problema?

El problema es que el buffer puede contener caracteres e información basura
provenientes de previas acciones realizadas en el programa.
El buffer no está "limpio", y puede que en la posición \( N-2 \) haya caracteres que no han sido colocados ahí por la última llamada a fgets().

La solución más natural sería limpiar tooooodo el buffer, poniendo todos sus caracteres a 0,
antes de cada llamada a fgets().  :'( :'(

Pero obviamente esto no hace falta.  8^) 8^)

Ya que toda la información que necesitamos está en buffer[N-2],
basta que "limpiemos" ese único caracter, poniéndolo a 0.  :-* :-*
Es extrañísimo, pero funcionará.

Esta limpieza extraña quiero hacerla así por una razón bien concreta:

* Es mucho menos costoso limpiar 1 solo caracter que toda una cadena de caracteres.

Si en el programa hacemos mucho uso de la "limpieza", estaríamos gastando muchos recursos.
El programa se vuelve lento...

Así que nos quedamos con esta versión de las cosas.
(Notar que el tamaño del buffer tiene que ser ahora \( N \geq 2 \) para que no haya problemas).


/* Elegir un valor de N que sea bastante grande, en particular, >= 2. */
char buffer[N];

buffer[N-2] = '\0'; /* Limpieza rápida del buffer */
fgets(buffer, N, stdin);
if ((buffer[N-2] != '\0') && (buffer[N-2] != '\n'))
   /* No se ha alcanzado el fin de línea */
   flush_stdin();
else
  /* Sí se ha alcanzado el fin de línea: no se hace nada. */
  ;




Como resultado de todos estos divagues, la versión 1.24 de bui.h contiene sólo modificaciones de la función bui_gets(), que queda ahora así:

(bui_gets():)

/* La siguiente función tiene ciertos efectos colaterales: */
/* [*] modifica bui_input.buffer                           */
/*                                                         */
/* Se usa la función "segura" fgets() en vez de gets()     */
/* No permite al usuario ingresar cadenas de longitud mayor que el buffer. */

void bui_gets(char *req) {
   
#define N __INPUT_STR_LEN /* Una abreviatura que usamos por un ratito. */
/* [#] N >= 2 */
/*     Si N < 2, esta rutina falla, pues se sobreescribe .buffer[N-2] */

    printf("%s", req);

    bui_input.buffer[N-2] = '\0'; /* Limpieza rápida del buffer (ver abajo) */
    fgets(bui_input.buffer, N, stdin);
    /* Se cumple la siguiente propiedad:                                */
    /* (no_se_alcanzó_fin_de_línea)                                     */
    /*          <---->                                                  */
    /* (.buffer[N-2] != '\0') && (.buffer[N-2] != '\n')                 */
    /* Por lo tanto es suficiente limpiar el caracter .buffer[N-2]      */
   
    if ((bui_input.buffer[N-2] != '\0') && (bui_input.buffer[N-2] != '\n'))
       /* No se ha alcanzado el fin de línea */
       while ( getchar() != '\n' ) /* flush_stdin... */
            /* ---> produce una descarga de stdin */
            /*      descartando caracteres hasta llegar al fin de línea */
           /* */ ;
    /* else ; */
      /* Sí se ha alcanzado el fin de línea: no se hace nada. */
   
#undef N
}


[cerrar]

19 Agosto, 2013, 07:21 am
Respuesta #17

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
Aún con bui_gets()...

Me molestan los efectos colaterales de bui_gets().

(Post modificado: he corregido bui_gets() para el caso N == 1).

En primer lugar quitaré la sentencia printf(req); de ahí,
y la moveré directamente al cuerpo de BUI_SCANF(), así:

printf(__req_msg);

Además, cambiaremos la manera de trabajar de bui_gets().
Haremos que se parezca a fgets():

Aceptará 2 parámetros: una string que hará de buffer para albergar los datos leídos, y un entero N que indica el máximo de caracteres a leer de la entrada estándar.

Ahora bui_gets() es una función de propósito general, que no depende de los datos de la estructura bui_input, por ejemplo.

En particular, tiene que manejar bien el caso \( N < 2 \).
Si N <= 0, tiene que retornar NULL y no hacer nada, porque no hay espacio disponible para ingreso de datos.
Si N == 1, entonces sólo hay espacio para 1 caracter: el nulo.
Para ser consecuentes, se lee la entrada estándar con fgets(),
pero sabemos ahora que, con toda seguridad, no se ha leído el fin de línea,
pues se han leído N - 1 == 0 caracteres.

En cualquier caso, puede que queden caracteres de "sobra", y se realiza la "limpieza" ya explicada.

Con comentarios y todo, queda así:


/* Se usa la función "segura" fgets() en vez de gets()                     */
/* No permite al usuario ingresar cadenas de longitud mayor que el buffer. */
/* buffer debe tener al menos N caracteres disponibles.                    */
/* Si buffer no es un array con tamaño suficiente, bui_gets() no es válida. */
char* bui_gets(char *buffer, int N) {
    if (N <= 0)
        /* No hay espacio para leer ---> error */
        return NULL;
    /* N >= 1 */
   
    if (N == 1) {
        /* Sólo hay espacio para el caracter nulo        */
        fgets(buffer, N, stdin);
        /* buffer[0] == '\0'; */
        /* Se han leído N - 1 == 0 caracteres            */
        /*     ---> No se ha podido leer el fin de línea */
        while(getchar()!='\n')
          ;
                 
        return buffer;
    };
    /* N >= 2 */   
     
    buffer[N-2] = '\0'; /* Limpieza rápida del buffer (ver abajo) */
    fgets(buffer, N, stdin);
    /* Se cumple la siguiente propiedad:                                */
    /* (no_se_alcanzó_fin_de_línea)                                     */
    /*          <---->                                                  */
    /* (buffer[N-2] != '\0') && (buffer[N-2] != '\n')                 */
    /* Por lo tanto es suficiente limpiar el caracter .buffer[N-2]      */
   
    if ((buffer[N-2] != '\0') && (buffer[N-2] != '\n'))
       /* No se ha alcanzado el fin de línea */
       while ( getchar() != '\n' ) /* flush_stdin... */
            /* ---> produce una descarga de stdin */
            /*      descartando caracteres hasta llegar al fin de línea */
           /* */ ;
    /* else ; */
      /* Sí se ha alcanzado el fin de línea: no se hace nada. */
     
    return buffer;
}
 



Esto obliga a cambiar el modo de usar bui_gets() dentro de BUI_SCANF().
Los cambios se notan sólo en el último bloque else,
y por eso sólo reproducimos ese trozo:


       else { \
           printf(__req_msg);                                               \
           bui_gets(bui_input.buffer, __INPUT_STR_LEN);                     \
           bui_input.special = __spfunc(bui_input.buffer);                  \

           /* resto del bloque else... */

       } /* else */ \




Además, todo lo que aparece dentro de la macro debe ser visible desde "afuera" de la librería bui.h.
Así que quitamos la línea que "undefine" __INPUT_STR_LEN:


// #undef __SHORT_STR_LEN /* Línea borrada */




Como ahora bui_gets() es una función de propósito general,
la mostraremos en la interface de la librería, prototipada y comentada, así:


/* bui_gets(char* buffer, int N):
/*     Lee la entrada estándar stdin hasta un máximo de N - 1 caracteres,
/*     y guarda los caracteres leídos en buffer.
/*     Tiene una semántica análoga a la de fgets().
/*     Si los caracteres leídos son N - 2 o menos,
/*     se incluye el caracter '\n' al final.
/*     En cualquier caso, se agrega un caracter nulo '\0' al final.
/*     Si quedan caracteres sin leer antes de alcanzar el fin de línea,
/*     se descartan todos los caracteres sobrantes y también el fin de línea.
/*
/*     Importante:
/*       Si N <= 0 retorna NULL no hace nada: retorna NULL.
/*       Si N >= 1 funciona de manera "normal".
/*
/* */
char* bui_gets(char*, int);




Ya hemos pulido bastante la librería bui.h, quitándole los efectos colaterales,
los gotos, las funciones no seguras, los problemas indeseables en la entrada que pudiera dar scanf(), etc., etc.

La coloco en spoiler para quien tenga ganas de probarla:

(bui.h versión 1.25):
bui0125.h:


/* ========================================================================= */
/* BUI.H 1.25 (Basic User Interface)
/*
/* Esta librería da una interface básica para presentar programas simples en C
/*
/* 2013/ago/18
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
/*
/* Esta librería provee una interface sencilla y sólida
/* para intercambio de información con el usuario por la E/S estándar.
/*
/* Hay una macro principal BUI_SCANF(), que reemplaza a la función scanf(),
/* y se encarga de gestionar la entrada por teclado de forma segura,
/* y gestionar situaciones de error de forma genérica.
/*
/* La estructura bui{} contiene campos de tipo char[], de longitud fija,
/* que pueden usarse para guardar en forma permanente
/* los mensajes e informaciones que necesita el programa
/* (nombre, vesión, autor, etc.; comentarios, ayudas, errores, mensajes, etc.)
/*
/* La estructura bui_input{} contiene campos
/* que controlan la entrada por teclado, y contienen señales de error.
/*
/* void bui_set_string(char *, char *):
/*    Función que se usa para asignar valores a los campos de bui{}.
/*
/* void bui_show_program_info(void):
/*    Función que muestre información básica del programa (contenida en bui{}).
/*
/* void bui_print_list(char (*list)[__LONG_STR_LEN]):
/*    Función que se usa para mostrar datos con formato de lista en bui{}.
/*
/* bool blank(char* ):
/*    Función de propósito general que indica si
/*    todos los caracteres de una cadena son blancos,
/*    siguiendo estrictamente las especificaciones
/*    de la función estándar isspace(),
/*    de la librería estándar ctype.h, según el estándar C99.
/*
/* ========================================================================= */

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>

/* */
/* struct { ... } bui;
/* ===================
/*
/* Es una estructura anónima que contiene strings.
/* Las strings de longitud "corta" se usan para información básica del programa.
/* Las strings de longitud "larga" se usan para información más compleja.
/*
/* program_name, program_vers, program_date, program_coun, program_auth:
/*   Son strings de longitud "corta", y se refieren a:
/*   Nombre (del programa), Versión, Fecha, País, Autor.
/*
/* program_purp, program_comm, program_help,
/* program_req, program_mess, program_err:
/*   Son strings de longitud "larga", y se refieren a:
/*   Propósito (del programa), Comentarios, Ayuda,
/*   Solicitudes al usuario (requests), Mensajes al usuario, Mensajes de error.
/*
/* En programas más complejos pueden requerirse varios mensajes distintos
/* del tipo de los indicados, y por eso se añaden listas de mensajes con
/* la misma temática, por si hicieran falta:
/*
/* program_comm_, program_help_,
/* program_req_, program_mess_, program_err_:
/*   Cada uno de ellos es un array de __MAX_LIST (16) strings "largas", para
/*   añadir distintos tipos de comentarios, ayudas, mensajes, errores, etc.
/*
/* Las macros constantes __SHORT_STR_LEN, __LONG_STR_LEN, __MAX_LIST,
/* albergan el tamaño prefijado de todas estas strings.
/* Sus valores no son accesibles desde el "exterior",
/* porque se "undefinen" al final del archivo.
/*
/* */

#define __SHORT_STR_LEN   32  /* Longitud string corta. */
#define  __LONG_STR_LEN 1024  /* Longitud string larga. */
#define __MAX_LIST        16  /* Longitud de listas de varios ítems en bui.h */

struct {
    char
      program_name[__SHORT_STR_LEN],
      program_vers[__SHORT_STR_LEN],
      program_date[__SHORT_STR_LEN],
      program_coun[__SHORT_STR_LEN],
      program_auth[__SHORT_STR_LEN],

      program_purp[__LONG_STR_LEN],
      program_comm[__LONG_STR_LEN],
      program_comm_[__MAX_LIST][__LONG_STR_LEN],
      program_help[__LONG_STR_LEN],
      program_help_[__MAX_LIST][__LONG_STR_LEN],
      program_req[__LONG_STR_LEN],
      program_req_[__MAX_LIST][__LONG_STR_LEN],
      program_mess[__LONG_STR_LEN],
      program_mess_[__MAX_LIST][__LONG_STR_LEN],
      program_err[__LONG_STR_LEN],
      program_err_[__MAX_LIST][__LONG_STR_LEN];
} bui;

/* */
/* struct { ... } bui_input;
/* =========================
/*
/* Es una estructura anónima que sirve para gestionar la entrada estándar.
/* Sus campos son:
/*
/*    char buffer[]:
/*          Un array de caracteres para albertar los datos de entrada.
/*    bool fatalerr:
/*          Vale true si en la última operación de entrada con BUI_SCANF()
/*          se ha utilizado una cadena de formato errónea.
/*          No todas las cadenas de formato erróneas producen "true".
/*          En general es un error del programador, y no del usuario.
/*    int special:
/*          Contiene un entero que significa algún tipo de comando "especial"
/*          que el usuario ha introducido con el teclado.
/*          Si el valor es BUI_NOT_SPECIAL ( == 0), quiere decir que
/*          el usuario ha intentado ingresar datos "normales".
/*    int errno:
/*          Contiene el resultado de la operación de entrada,
/*          el cual coincide con el que generaría sscanf(),
/*          siempre que su valor sea modificado por las operaciones "internas"
/*          de éste archivo de librería.
/*    bool userinputerr:
/*          Es un "flag" (banderín) que informa si la última operación
/*          de entrada ha tenido errores (true) o ha sido exitosa (false).
/*          Para ser consecuentes con este significado,
/*          se inicializa su valor a "false" al principio del programa.
/*
/* La longitud de la cadena "buffer" es __INPUT_STR_LEN,
/* que es una macro constante inaccesible desde el "exterior",
/* pues se "undefine" al final del archivo.
/* Tiene un valor de 130, suficiente para la consola típica de 128 caracteres,
/* más 1 caracter nulo que agrega al final la función gets().
/* Si se va a correr el programa en un entorno donde la consola admita entradas
/* más extensas, este valor no sería suficiente.
/* (Mas, sería preferible recortar la entrada, antes que agrandar el buffer.)
/*
/* */

#define __INPUT_STR_LEN  130  /* Longitud string datos entrados por teclado. */
#define BUI_NOT_SPECIAL 0     /* Debe ser siempre 0 */

struct {
    char buffer[__INPUT_STR_LEN];
    bool fatalerr;
    int special;
    int  errno;
    bool userinputerr;
} bui_input =
   { .buffer  = "",
     .fatalerr = false,
     .special  = BUI_NOT_SPECIAL,
     .errno    = 0,
     .userinputerr = false
   };

/* bui_set_string(char* dest, char* src):
/*     Copia la cadena src en la cadena dest.
/*     Su propósito es asignar valores a las strings de la estructura bui{}.
/*     Ejemplo:
/*       bui_set_string(bui.program_comm, "Este programa calcula el M.C.D.\n");
/* */
void bui_set_string(char* restrict, const char* restrict);

/* bui_show_program_info():
/*     Muestra en pantalla la información básica del programa,
/*     con un formato predefinido:
/*
/* NOMBRE VERSIÓN
/* FECHA PAÍS
/* AUTOR
/*
/* Los datos consignados son leídos directamente de los campos de gui{}:
/*    program_name, program_vers, program_date, program_coun, program_auth.
/*
/* Al final agrega una línea en blanco como separador.
/* */
void bui_show_program_info(void);

/* bui_print_list():
/*     Muestra en pantalla todas las strings de un array de strings,
/*     tal que cada string tiene longitud __LONG_STR_LEN.
/*     Las muestra en secuencia según su índice de array, de 0 a __MAX_LIST.
/*     Agrega un caracter fin_de_línea \n al final de cada ítem de la lista.
/*     Si un ítem es una cadena vacía (""), no hace nada.
/* */
void bui_print_list(char (*list)[__LONG_STR_LEN]);

/* Macro:
/* BUI_SCANF(REQ_MSG, ERROR_MSG, SPFUNC, FMT, ...) 
/*
/* Macro para la entrada de datos, al estilo de scanf() o sscanf().
/* (Es decir, acepta un número variable de parámetros).
/*
/* REQ_MSG:
/*    Es una string (char*) que contiene un mensaje para dar al usuario
/*    con una solicitud de que ingrese datos de cierta clase.
/*    Si no se ingresa un (char*) el compilador lo detectará.
/* ERROR_MSG:
/*    Es una string (char*) que contiene un mensaje de error,
/*    el cual se mostrará al usuario en caso de ingreso erróneo de datos.
/*    Si no se ingresa un (char*) el compilador lo detectará.
/* SPFUNC:
/*    Es el nombre de una función del tipo: int (* ) (char*) (o compatible...).
/*    Es decir, una función que acepta un char* como único parámetro,
/*    y que retorna un int.
/*    Si se pasan otros tipos de objetos o de funciones incompatibles,
/*    el compilador lo detectará.
/*    Se utiliza para detectar comandos especiales ingresados por el usuario.
/*    Cada comando tendrá asociado un número entero distinto de 0,
/*    y el número asignado dependerá de la función SPFUNC,
/*    que es proveída por el programador.
/* FMT:
/*    Es una cadena de formato que funciona igual que las de scanf().
/*    (Sólo el caso de dígitos interpuestos entre un par de % %
/^     fuciona de modo diferente. Sin embargo, este caso es erróneo tanto
/*     para sscanf como para BUI_SCANF() ).
/* ...:
/*    Número variable parámetros, en donde se han de consignar
/*    las direcciones de memoria de las variables a ser asignadas durante
/*    el proceso de lectura de datos
/*    (según las directivas de tipos de datos consignados en FMT).
/*
/* Para usar la macro BUI_SCANF() se deben consignar todos los parámetros
/* arriba explicados, y además al menos 1 parámetro más en la lista variable.
/* Al principio la macro define variables de los tipos deseados,
/* e intenta asignarles directamente los parámetros.
/* Si esto no fuera posible, el programa no compilará.
/* En el resto de la macro se usan las variables, pues tienen tipos concretos.
/*
/* Se analiza la cadena de formato FMT, y si contiene un error se informa
/* en el campo bui_input.fatalerr, terminando la macro inmediatamente.
/*
/* Si no, se lee una línea de la entrada estándar (hasta el 1er fin de línea).
/* Estos caracteres se guardan en bui_input.buffer.
/*
/* Con la función SPFUNC() (pasada como parámetro por el programador),
/* se analiza la línea de entrada, y se intenta detectar un comando "especial".
/* En caso afirmativo (un valor no nulo), esto se registra en la variable
/* bui_input.special, y se termina la macro inmediatamente.
/*
/* Luego se "releen" los caracteres del buffer, y se intenta convertirlos
/* en valores apropiados, según indique la cadena de formato FMT,
/* pasando estos valores a la lista variable de parámetros.
/* El método en que se realiza esta asignación es idéntico al de sscanf().
/* El resultado de esta operación es un entero (int),
/* igual al valor que generaría una llamada a sscanf().
/* Este valor queda guardado en:
/*         bui_input.errno
/* Se calcula la cantidad de asignaciones esperadas
/* (esto se logra calculando la cantidad de caracteres '%' de FMT
/* que realmente se usarán para asignar valores a variables).
/* El cálculo se hace con la función:
/*        int __bui_N_ARGS(char* );
/* Se compara este valor con el almacenado en bui_input.errno,
/* y el resultado se guarda como un valor bool en
/*        bui_input.error_state
/* Su valor es "true" cuando la comparación de los dos valores falla.
/* Esto es indicativo de "error" de lectura: significa que el usuario
/* ha ingresado datos erróneos, y esto quedar consignado en
/* la variable bui_input.userinputerr.
/* En ese caso se envía al usuario el mensaje de error ERROR_MSG.
/*
/* La rutina que llamó a la macro BUI_SCANF() tiene que verificar
/* los campos de bui_input, y actuar en consecuencia.
/* El modo de hacer esto tiene que ser el siguiente:
/*
/* if(bui_input.fatalerr)
/*   /* Finalizar el programa */
/* else if (bui_input.special)
/*       switch(bui_input.special) {
/*           case 1: /* ejecutar rutina 1 */
/*           break;
/*           case 2: /* ejecutar rutina 2 */
/*           break;
/*           /* ... ^/
/*           case N: /* ejecutar rutina N */
/*           break;
/*       }
/* else if (bui_input.userinputerr)
/*     /* Realizar acción asociada a ingreso de datos erróneos del usuario */
/* else
/*    /* Entrada de datos "normal", compatible con la cadena de formato FMT */
/*    /* Realizar acciones con los datos ingresados por el usuario */
/*
/* Ejemplo de uso:
/*
/* #include bui0120.h
/*
/* int main(void) {
/*     float x, y, z;
/*
/*     BUI_SCANF("Ingrese 3 números: ", "Error! Intente otra vez!\n",
                 blank,
/*               "%f %f %f", &x, &y, &z
/*     );
/*
/*     if(bui_input.fatalerr)
/*     else if (bui_input.special)
/*          switch(bui_input.special) {
/*              case 1: return 0; /* FIN DEL PROGRAMA */
/*              break;
/*          }
/*     else if (bui_input.userinputerr)
/*         printf("No puedo calcular nada con esa actitud tuya!! :( \n\n");
/*     else
/*         printf("Datos correctos!\nSu promedio es: %f\n\n", (x+y+z)/3);
/*
/*     return 0;   
/* }
/*
/* Precauciones:
/* =============
/*      La cadena de formato FMT sólo reconoce directivas de C99.
/*      Opciones adicionales o de C11 y ss. no son reconocidas.
/* */

/* blank():
/*     Decide si la cadena de caracteres tomada como parámetro
/*     contiene sólo caracteres "blancos" (y retorna true), o no (false).
/*     El significado de "caracter blanco" es el mismo que
/*     interpreta isspace() de la librería estándar ctype.h.
/* */
bool blank(char* );

/* bui_gets():
/*     Lee la entrada estándar stdin hasta un máximo de N - 1 caracteres,
/*     y guarda los caracteres leídos en buffer.
/*     Tiene una semántica análoga a la de fgets().
/*     Si los caracteres leídos son N - 2 o menos,
/*     se incluye el caracter '\n' al final.
/*     En cualquier caso, se agrega un caracter nulo '\0' al final.
/*     Si quedan caracteres sin leer antes de alcanzar el fin de línea,
/*     se descartan todos los caracteres sobrantes y también el fin de línea.
/*
/*     Importante:
/*       Si N <= 0 retorna NULL no hace nada: retorna NULL.
/*       Si N >= 1 funciona de manera "normal".
/*
/* */
char* bui_gets(char *buffer, int N);
   
/* ========================================================================= */
/* Implementación:
/* */

void bui_show_program_info(void) {
    printf("%s %s\n%s %s\n%s\n\n",
       bui.program_name, bui.program_vers,
       bui.program_date, bui.program_coun,
       bui.program_auth,
       bui.program_purp
    );
/* Los datos se muestran con el formato:
/* ----------------------------------------- */
/* NOMBRE VERSIÓN
/* FECHA PAÍS
/* AUTOR
/*
/* ----------------------------------------- */
}

void bui_print_list(char (*list)[__LONG_STR_LEN]) {
    for (int i = 0; i < __MAX_LIST; i++)
      if (list[i][0])
         /* list[i] == "" */
         /* Como puts() agrega un fin de línea,                       */
         /* se desea que este efecto no ocurra si la cadena es vacía: */
         puts(list[i]);
}

void bui_set_string(char* restrict dest, const char* restrict src) {
    /* Copia src en dest */
    /* Las direcciones de las strings originales no son alteradas. */
    /* Sin embargo se modifica el contenido de dest.               */
    /* (No se cambia el contenido de src).                         */
    /* Se realiza la asignación caracter a caracter, */
    /* luego se compara el valor asignado contra 0,  */
    /* en cuyo caso el proceso termina.              */
    /* Si no termina, se avanza una posición de memoria en cada string. */
    for( ; (*dest = *src) != '\0'; src++, dest++)
      ;
}
/* ---> OUT: dest == src, strlen(dest) == strlen(src) */

/* Se usa la función "segura" fgets() en vez de gets()                     */
/* No permite al usuario ingresar cadenas de longitud mayor que el buffer. */
/* buffer debe tener al menos N caracteres disponibles.                    */
/* Si buffer no es un array con tamaño suficiente, bui_gets() no es válida. */
char* bui_gets(char *buffer, int N) {
    if (N <= 0)
        /* No hay espacio para leer ---> error */
        return NULL;
    /* N >= 1 */
   
    if (N == 1) {
        /* Sólo hay espacio para el caracter nulo        */
        fgets(buffer, N, stdin);
        /* buffer[0] == '\0'; */
        /* Se han leído N - 1 == 0 caracteres            */
        /*     ---> No se ha podido leer el fin de línea */
        while(getchar()!='\n')
          ;
                 
        return buffer;
    };
    /* N >= 2 */   
     
    buffer[N-2] = '\0'; /* Limpieza rápida del buffer (ver abajo) */
    fgets(buffer, N, stdin);
    /* Se cumple la siguiente propiedad:                                */
    /* (no_se_alcanzó_fin_de_línea)                                     */
    /*          <---->                                                  */
    /* (buffer[N-2] != '\0') && (buffer[N-2] != '\n')                 */
    /* Por lo tanto es suficiente limpiar el caracter .buffer[N-2]      */
   
    if ((buffer[N-2] != '\0') && (buffer[N-2] != '\n'))
       /* No se ha alcanzado el fin de línea */
       while ( getchar() != '\n' ) /* flush_stdin... */
            /* ---> produce una descarga de stdin */
            /*      descartando caracteres hasta llegar al fin de línea */
           /* */ ;
    /* else ; */
      /* Sí se ha alcanzado el fin de línea: no se hace nada. */
     
    return buffer;
}
 
/* Buscar un caracter en una cadena */
bool char_in_str(char c, char* s) {
   for ( ; *s; s++)
      if (c == *s)
         return true; /* c "pertenece" a s */
   /* c "no pertenece" a s */   
   return false;     
}

/* Conjunto de directivas de reemplazo efectivo por argumentos válidos      */
/* en funciones del estilo de scanf(), en la librería stdio.h, de C99 o ss. */

#define SCANF_SAFE_ARG_SET_C99 "hljztLdiouxaefgc[pAEFGXn0123456789"
#define SCANF_SAFE_SPE_SET_C99 "*"
#define SCANF_SAFE_DIGITS      "0123456789"

/* Indicador de que se halló una directiva no válida en la cadena de formato */
#define BUI_FMT_NOT_VALID -1 /* Debe ser < 0 */

/* El entero retornado por __bui_N_ARGS() es: *(
/* n >= 0: Se hallaron n directivas válidas (C99) para argumentos reales.   */
/* n < 0:  Error: hay directivas no reconocidas.                            */
/* Nota adicional: Las directivas que contienen dígitos antepuesto ("%20f") */
/* son reconocidas correctamente. */
/* Nota ténica: */
/* Los casos "%digitos%" son erróneos en C99 (ver sección 7.19.6.2.12).     */
/* pero al mismo tiempo son reconocidos inexactamente por __bui_N_ARGS().   */
/* El resultado es un programa erróneo en cualquier caso, aunque            */
/* la "semántica" para este caso de sscanf() y BUI_SCANF() no coincidirá.   */
int __bui_N_ARGS(char *s) {
    int n;
    bool before = false;
   
    for (n = 0; *s; s++)
      /* n == 0 ---> before == false */
      /* n > 0  --->                                              */
      /*     [ (último caracter leído no-dígito de s) == '%'      */
      /*               <----> before == true ]                    */
      if (*s == '%')
        /* Recordar que se ha encontrado un signo '%' en esta posición, */
        /* pero no tomar ninguna acción.                                */
        /* Si antes ya había un '%', es que estamos ante el caso %%,    */
        /* y entonces se debe "cancelar" el estado del flag "before".   */
        /* Si no, registramos la aparición de '%' como true,            */
        /* para ser analizado en la siguiente iteración.                */
        before = ( (before)? false: true );
      else {
        /* El caracter actual no es '%' */   
        if (before)
          /* *(s-1) == '%' (el caracter previo era un '%')          */
          /* Directiva % detectada.                                 */
          if (char_in_str(*s, SCANF_SAFE_DIGITS))
             /* Si se encuentra un dígito, mejor ignorarlo,                 */
             /* y seguir buscando el próximo caracter que no sea un dígito. */
/* CONTINUE */
             continue;
             /* before == true */
             /*     ---> Directivas con dígitos se reconocen correctamente. */
             
          else if (char_in_str(*s, SCANF_SAFE_ARG_SET_C99))
             /* La directiva % hallada corresponde a un caso "seguro",  */
             /* que además corresponde a un argumento real.             */
             /* ---> entonces incrementar el contador.                  */
             n++;
          else if (char_in_str(*s, SCANF_SAFE_SPE_SET_C99))
             /* La directiva % hallada corresponde a un caso "seguro",  */
             /* pero que no corresponde a un argumento real.            */
             ; /* Nada */
          else
             /* Se encontró una directiva desconocida. */
             /* Se termina abruptamente la función y retorna error. */
/* RETURN */
             return BUI_FMT_NOT_VALID; /* < 0 */
        else /* if(before) */
          ;
                   
        before = false;
        /* Se registra para la iteración siguiente */
        /* que el caracter actual no es un '%'     */
      }
    /* n == número de directivas % halladas en s.                        */
    /* Sólo se cuentan casos que efectivamente se asignan a argumentos,  */
    /* de los tipos especificados por el estándar C99.                   */
    /* No se cuentan los casos de %%, %*.                                */
           
    return n;         
}

bool blank(char *s) {
    for ( ; *s; ++s)
       if (!isspace(*s))
          /* Se ha encontrado un caracter que no es blanco. */
          return false;
     
    /* s es una string que sólo contiene blancos (al "estilo" isspace()) */
    return true;
}

#define BUI_SCANF(REQ_MSG, ERROR_MSG, SPFUNC, FMT, ...) { \
       char *__req_msg = REQ_MSG;                 \
       /* [--->] typedef(REQ_MSG) == (char*) */   \
       char *__error_msg = ERROR_MSG;             \
       /* [--->] typedef(ERROR_MSG) == (char*) */ \
       char *__fmt = FMT;                         \
       /* [--->] typedef(FMT) == (char*) */       \
       bool (*__spfunc)(char*) = SPFUNC;          \
       /* [--->] typedef(SPFUNC) == bool (función) (char*) */   \
       \
       int __n_args = __bui_N_ARGS(__fmt);                           \
       /* __bui_N_ARGS(__fmt) == número de directivas "reales" en __fmt */ \
       bui_input.fatalerr = (__n_args < 0);                          \
       if (bui_input.fatalerr)                                       \
           printf("Fatal error: format string is wrong.\n");         \
       else { \
           printf(__req_msg);                                               \
           bui_gets(bui_input.buffer, __INPUT_STR_LEN);                     \
           bui_input.special = __spfunc(bui_input.buffer);                  \
           if (bui_input.special == BUI_NOT_SPECIAL) {                      \
               /* Caso "normal" de ingreso de datos. */                     \
               /* [#] __VA_ARGS__  == lista de punteros a variables   */    \
               bui_input.errno = sscanf(bui_input.buffer, __fmt, __VA_ARGS__);\
               /* bui_input.errno: entero de significado análogo al      */ \
               /*                  valor de retorno de sscanf()          */ \
               bui_input.userinputerr = (bui_input.errno < __n_args);       \
               if (bui_input.userinputerr)                        \
                      printf(__error_msg);                          \
          } /* if(bui_input.special == 0) */ \
          else \
             ; /* No se hace nada si bui_input.special != 0 */ \
       } /* else */ \
    }

/* Quitamos las definiciones de los símbolos definidos en la librería */
/* para que queden inaccesibles desde archivos externos. */

#undef __SHORT_STR_LEN
#undef __LONG_STR_LEN
#undef __MAX_LIST
#undef SCANF_SAFE_ARG_SET_C99
#undef SCANF_SAFE_SPE_SET_C99
#undef SCANF_SAFE_DIGITS
#undef BUI_FMT_NOT_VALID

[cerrar]



Hay muchas mejoras técnicas posibles,
pero las dejaremos para otro momento.
Por ahora me doy por satisfecho.

 :-*

19 Agosto, 2013, 08:58 am
Respuesta #18

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,797
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
(En el post anterior voy a quitar el scanf("%*c");, que no es buena idea, por el bucle while() que limpia stdin...)