22/09/2019, 08:05:49 pm *
Bienvenido(a), Visitante. Por favor, ingresa o regístrate.
¿Perdiste tu email de activación?

Ingresar con nombre de usuario, contraseña y duración de la sesión
Noticias: Homenaje a NUMERARIUS
 
 
Páginas: [1]   Ir Abajo
  Imprimir  
Autor Tema: Programación en C: Pare de sufrir: Alternativas a la consola  (Leído 1155 veces)
0 Usuarios y 1 Visitante están viendo este tema.
argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Conectado Conectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.275

Vean mis posts activos en mi página personal


Ver Perfil WWW
« : 11/01/2013, 05:54:57 pm »

Pare de sufrir: Alternativas a la consola

(Este tema ha sido recortado del Proyecto de Curso: Programación en C)

Ya que nuestros programas hasta el momento sólo muestran información en la pantalla, sin interactuar con el usuario de otra manera, existen alternativas para que podamos ver la información de una manera más agradable al ojo humano, que no sea la odiosa consola negra fea de 80x25 de la línea de comandos:enojado: :enojado: :enojado: :enojado: :enojado: :enojado: :enojado:

Otro inconveniente que teníamos es la incompatiblidad de los conjuntos de caracteres que hay entre la línea de comandos y el resto de programas que corren bajo Windows.
Esto se soluciona con los trucos que explicaremos aquí.
En particular, se visualizarán bien los acentos, eñes y demás caracteres especiales:beso: :beso: :beso:


Hasta ahora veníamos "frenando" el programa con sentencias como getchar() o system("PAUSE"), mientras nuestros ojos soportaban una visualización horrible de la información en la ventanita incómoda de la línea de comandos.

Podemos dejar de sufrir un poco con ese tipo de cosas con algunos trucos muy sencillos.

A continuación expondremos:

  • Truco 1: Mostramos, usando comandos de sistema, cómo  mandar la salida de nuestros programas a un archivo de Word, en vez de la pantalla.

  • Truco 2: Mostramos, usando comandos de sistema, cómo simular que presionamos varias veces la tecla ENTER, sin usar el teclado, y así quitamos los "frenos" a nuestros programas.

    Importante: aquí se define un archivo ENTERS.TXT que es necesario en los demás trucos.


  • Truco 3: Otra vez mostramos, usando comandos de sistema, cómo mandar la salida de nuestros programas a un archivo de Word, en vez de la pantalla, pero esta vez eliminamos todos los "frenos" producidos cada vez que un programa esperaba que el usuario presione la tecla ENTER para poder continuar.

  • Truco 4: Mostramos, esta vez usando sentencias básicas del lenguaje C, cómo mandar la salida de nuestros programas a un archivo de Word, en vez de la pantalla.

  • Truco 5: Mostramos, usando comandos de sistema, cómo mandar la salida de nuestros programas a un archivo HTML, en vez de la pantalla, para que se abra con el navegador, y que se visualice correctamente.

    Este es mi preferido.   :sonrisa_amplia: :sonrisa_amplia: :sonrisa_amplia: :sonrisa_amplia:




Para esto, primero tenemos que abrir la línea de comandos de Windows:

Clic en el menú Inicio de Windows, clic en "Ejecutar..." (o alguna opción equivalente), y luego escribir CMD. Finalmente, clic en "Aceptar".
Otra alternativa para esto es así: Clic en menú Inicio, clic en Programas, clic en Accesorios, clic en "Símbolo del Sistema".

Una vez que estamos en la línea de comandos, tenemos que acceder a la carpeta donde tenemos nuestros proyectos de lenguaje C.
Supongamos que tenemos guardados nuestros proyectos en la siguiente carpeta:

C:\Documents and Settings\Admin\MisDocumentos\MisProyectosC

En ese caso accedemos con este comando:

CD "C:\Documents and Settings\Admin\MisDocumentos\MisProyectosC"

Puede que las comillas no sean necesarias, pero usándolas es seguro que funciona correctamente.

Hay que escribir correctamente la ubicación de la carpeta.


Truco número 1: Redirigir la salida de consola (o pantalla).

Spoiler: Truco 1 (abrir para ver) (click para mostrar u ocultar)




Truco 2: Redirigir la entrada de consola (teclado).

Importante: Aquí crearemos un archivo llamado ENTERS.TXT,
que vamos a usar en los demás trucos.

Spoiler: Truco 2 (abrir para ver) (click para mostrar u ocultar)



Truco 3: Redirección automática de la entrada y la salida de consola, juntas.

Spoiler: Truco 3 (abrir para ver) (click para mostrar u ocultar)



Truco 4: Redirigir la salida de datos desde dentro del programa mismo.

Spoiler: Truco 4 (abrir para ver) (click para mostrar u ocultar)



Truco 5: Redirigir la salida a un archivo HTML, para visualizarlo correctamente en el navegador.



A fin de automatizar todo esto, creamos un nuevo proceso por lotes, llamado:

EjecutarYVerHtml.bat


ECHO ^<pre^>      >  OUTPUT.HTML
%1   < ENTERS.TXT >> OUTPUT.HTML
ECHO ^</pre^>     >> OUTPUT.HTML
OUTPUT.HTML


Guardamos eso, y simplemente ejecutamos en línea de comandos lo siguiente:

EjecutarYVerHtml.bat HolaMundo.exe

Eso nos mostrará el mensaje de "Hola Mundo" en nuestro navegador.

Para tener un ejemplo más interesante, hagamos lo mismo con el programa TestingIntegers2.exe:

EjecutarYVerHtml.bat TestingIntegerse2.exe

 :sonrisa_amplia:






Organización

Comentarios y Consultas
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Conectado Conectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.275

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #1 : 12/01/2013, 02:56:06 am »

Aprendiendo lo básico del lenguaje HTML

En el post anterior vimos un truco para visualizar nuestros viejos programas cómodamente como una página en el navegador web.

Pero ahora que ya nos animamos a trabajar así, sería deseable aprovechar las capacidades de formato del lenguaje HTML, visualizando los resultados de un modo más agradable a la vista.
O sea que vamos a aprender algo de HTML:lengua_afuera:

La idea es introducir el código HTML directamente desde nuestros programas en C, pero tenemos que hacerlo de una manera que no sea incómoda, sino tenerlo más o menos automatizado.
Por ejemplo, con la ayuda de macros.

Además, podemos definir macros de compilación condicional, para elegir si queremos generar una salida apropiada para la ventana de comandos de Windows, o si queremos una salida apropiada para HTML, o bien alguna otra cosa que se nos ocurra.



Aquí presentamos los elementos más básicos de HTML.

El HTML es un lenguaje de marcado o bien de etiquetas, lo cual quiere decir, más o menos, que su función no es ejecutar un programa, como lo que normalmente hacemos en C, sino que está orientado a visualizar información, permitiendo diversos formatos de estilo.
Se orienta al aspecto visual.

Los archivos HTML se visualizan con programas específicos: los navegadores web. Por ejemplo:

Chrome, Firefox, Opera, Explorer, etc.

Sin embargo, el modo definitivo en que se visualiza una página HTML depende del navegador.
Lo que el HTML hace en realidad es indicar tan sólo la manera lógica en que están relacionados los datos internamente.
Por ejemplo, indica si los datos son una tabla, o un enlace a una web, o un título, etc.

Luego, el navegador implementa ese formato lógicamente estipulado, y lo muestra al usuario como mejor puede o se le ocurre.

En un archivo HTML se puede poner texto plano, y se mostrará así como aparece, salvo por el hecho de que HTML elimina todos los espacios en blanco redundantes, y los saltos de línea.

El lenguaje HTML especifica su comportamiento en base a etiquetas.
Nos vamos a concentrar por ahora en las etiquetas que permiten darle formato al texto.

Si una etiqueta tiene un determinado nombre, por ejemplo "b", entonces tiene que abrirse y cerrarse, para que pueda aplicarse correctamente, y el archivo HTML esté correcto sintácticamente.
Para abrirla usaríamos <b>, y para cerrarla </b>, o sea, se agrega una barra / para cerrar la etiqueta.



Las etiquetas más comunes que podemos llegar a usar, serían éstas:

<pre> ....... </pre>: Se usa para que HTML respete los espacios en blanco y los saltos de línea, dejando que el texto se vea tal cual lo hemos escrito.

<b> .... </b>: Se usa para encerrar texto que va en negritas.
<i> .... </i>: Se usa para encerrar texto que va en cursiva.
<u> .... </u>: Se usa para encerrar texto que va subrayado.

<font color="blue"> ....  </font>:  Se usa para cambiar el color de la fuente del texto.
<font size=4> ....  </font>:  Se usa para cambiar el tamaño de la fuente del texto.
<font face="Arial"> ....  </font>:  Se usa para cambiar el tipo de letra de la fuente del texto.

<a href="www.rinconmatematico.com/foros/"> .....  </a>: Se usa para poner enlaces a páginas web.



Ahora explicamos cómo se usan esas etiquetas:

Para poner un texto en negrita, o en cursiva, o subrayado, podemos encerrarlo entre las etiquetas correspondientes, así:

<b>¡Hola Mundo!</b> <i>¡Hola Mundo!</i> <u>¡Hola Mundo!</u>

Esto muestra:

¡Hola Mundo! ¡Hola Mundo! ¡Hola Mundo!

Se pueden usar combinados, por ejemplo:

<b><i><u>¡Hola Mundo!</u> </i></b>  ¡Hola Mundo!¡Hola Mundo!

Resulta:

¡Hola Mundo!

Si ahora queremos cambiar el color, el tamaño y/o el tipo de las fuentes, hacemos:

<font color="blue">¡Hola Mundo!</font>
<font size=4>¡Hola Mundo!</font>
<font face="Arial">¡Hola Mundo!</font>

Que producen:

¡Hola mundo!
¡Hola Mundo!
¡Hola mundo!

Hay muchos colores disponibles a través de sus nombres en inglés, por ejemplo:

Aqua
Black
Blue
Fuchsia
Gray   
Green
Lime
Maroon   
Navy
Olive
Purple
Red
Silver
Teal
White (white).
Yellow

También es posible indicar colores mediante la paleta RGB, en hexadecimal, poniendo dos dígitos hexadecimales por cada color primario (R: Red, G: Green, B: Blue).
El valor hexadecimal indica una tonalidad, que va de lá más oscura (con 00, ausencia de color), hasta la más clara (con FF, presencia plena de color).

Ejemplo:

<font color="#FC28A5">¡Hola Mundo!</font>

que produce:

¡Hola Mundo!

Debemos interpretar el código hexadecimal así: #RRGGBB, o sea, los dos primeros dígitos corresponden a Red, los dos que siguen a Green, y los últimos dos a Blue.

Si nos interesa estar seguros de usar colores compatibles en todos los sistemas,
o sea, que se muestren por igual en todos los programas que interpreten HTML, podemos usar los siguientes valores hexadecimales:

00, 33, 66, 99, CC, FF

En cuanto al tipo de fuente, no podemos asegurar que todos los sistemas contengan todos los tipos de letra que tenemos nosotros.
Podemos quizá estar seguros de las más típicas. He aquí el modo de uso:

<font face="Arial">¡Hola mundo! (Arial)</font>
<font face="Times">¡Hola mundo! (Times)</font>
<font face="Helvetica">¡Hola mundo! (Helvetica) </font>
<font face="Verdana">¡Hola mundo! (Verdana) </font>
<font face="Courier">¡Hola mundo! (Courier) </font>


Que produce:

¡Hola mundo! (Arial)
¡Hola mundo! (Times)
¡Hola mundo! (Helvetica)
¡Hola mundo! (Verdana)
¡Hola mundo! (Courier)

El tamaño de la fuente es un número que puede variar de 1 a 7:

<font size=1>¡Hola mundo! (Tamaño 1)</font>
<font size=2>¡Hola mundo! (Tamaño 2)</font>
<font size=3>¡Hola mundo! (Tamaño 3)</font>
<font size=4>¡Hola mundo! (Tamaño 4)</font>
<font size=5>¡Hola mundo! (Tamaño 5)</font>
<font size=6>¡Hola mundo! (Tamaño 6)</font>
<font size=7>¡Hola mundo! (Tamaño 7)</font>


Que produce (aproximadamente, ya que no puedo reproducir aquí el resultado exacto):

¡Hola mundo!
¡Hola mundo!
¡Hola mundo!
¡Hola mundo!
¡Hola mundo!
¡Hola mundo!
¡Hola mundo!


Todas estas etiquetas pueden combinarse formando estilos que tengan negritas, cursivas, colores, tamaños y tipos de fuentes, de lo más variados.

Por último comentemos la etiqueta más importante de todas en el HTML, que es la que permite mostrar enlaces a otras páginas webs. Ejemplo:

<a href="www.rinconmatematico.com">Página del Rincón Matemático</a>

que produce:

Página del Rincón Matemático

Como se puede apreciar, la dirección real de la página web queda escondida al usuario, y es conocida sólo por HTML, mientras que lo que al usuario se le muestraes lo que está encerrado entre las etiquetas <a> y </a>, que es más bien algo informativo.



Un detalle importante:

En HTML los caracteres < > " &
se consideran especiales, y si intentamos generarlos como texto normal,
es muy posible que obtengamos algunos errores.
Para evitar esto, y generar páginas HTML "sólidas",
debemos generarlos con códigos especiales, como los siguientes:

&lt;   genera <
&gt;   genera >
&quot; genera "
&amp;  genera &



En el próximo post vamos a ver cómo generar una salida de nuestros programas en formato HTML,
mediante el uso de macros apropiadas, así como compilación condicional.







Organización

Comentarios y Consultas
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Conectado Conectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.275

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #2 : 12/01/2013, 02:58:56 am »

Macros para generar salida HTML


Vamos a declarar macros para obtener salida para HTML en nuestros programas.


#define HTML_BPRE "<pre>"
#define HTML_EPRE "</pre>"


Esas dos macros se encargan de abrir y cerrar las etiquetas del modo preformateado de HTML, lo cual hace que se muestre en el documento HTML el texto justo en la forma en que lo escribimos, sin omitir espacios en blanco o saltos de línea.


#define _BOLD(X)  "<b>" X "</b>"
#define _ITALIC(X) "<i>" X "</i>"
#define _UNDERLINE(X) "<u>" X "</u>"


Esas macros se usarán para productir etiquetas que generen negrita, cursiva y subrayado en nuestros documentos HTML. Ejemplos de uso:

_BOLD("negrita")
_ITALIC("cursiva")
_UNDERLINE("subrayado")




#define _COLOR(C, X) "<font color=" C ">" X "</font>"
#define _FACE(F, X) "<font face=" F ">" X "</font>"
#define _SIZE(S, X) "<font size=" S ">" X "</font>"


Esas macros se usarán para cambiar momentáneamente atributos de la fuente: color, tipo de letra, tamaño.
Ejemplos de uso:

_COLOR("\"blue\"", "Poniendo texto azul.")
_FACE("\"Arial\"", "Eligiendo tipo de letra Arial")
_SIZE("4", "Eligiendo tamaño de letra 4")

Tanto los colores como los tipos de letra tienen que llevar un doble entrecomillado, porque el lenguaje HTML también espera ver "comillas" en los parámetros que le indican el color o el tipo de la letra.
Esto amerita que usemos secuencias de escape \" para poder poner correctamente caracteres de comillas dentro de la string pasada como parámetros a las macros.
En cambio, el "4" de _SIZE, si bien va entre comillas, no requiere más precauciones.

#define _URL(L, X) "<a href=" L ">" X "</a>"

Esa macro se usa para escribir un enlace URL. Ejemplo:

_URL("\"http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248\"", "Programación en C: curso online")

Obsérvese que en ese caso también hay que tomar la precaución de colocar un entrecomillado doble.

#define _BFACE(F) "<font face=" F ">"
#define _EFACE    "</font>"

Esas dos macros se usan de a pares. Si una está presente en el programa, la otra también tendrá que estarlo.
Se usa para elegir el tipo de fuente que elegiremos para todo el documento.
Ejemplo de uso:

_BFACE("\"Arial\"")

_BFACE


De nuevo, se hizo necesario un entrecomillado doble.

Finalmente:


#define _BSIZE(S) "<font size=" S ">"
#define _ESIZE    "</font>"


También se usan apareadas, y sirven para elegir el tamaño de la fuente en todo el documento HTML.
Los tamaños posibles son, hasta donde sé, de "1" hasta "7" (hay que poner las comillas).

Por último, vamos a necesitar tener definidas unas macros para los caracteres especiales de HTML:


#define _LT    "&lt;"      /* Signo < */
#define _GT    "&gt;"      /* Signo > */
#define _AMP   "&amp;"      /* Signo & */
#define _QUOTE "&quot;"      /* Comilla doble: \" */




Las macros anteriores se pueden usar "concatenadas" y "anidadas".
Esto se debe a que con mucho cuidado y a propósito, las hemos diseñado de modo que ellas representen strings.
Los parámetros que se les pasen tienen que ser siempre strings para que funcionen bien.

Además, para que realmente se vea su efecto, se tienen que usar con printf.

Para ver ejemplos de uso, directamente pasemos a un programa del estilo "Hola mundo", pero que muestra algunos ejemplos de concatenación y anidamiento de las macros, generando adecuadas y bien ordenadas etiquetas HTML.

Otra recomendación: las macros apareadas, como (HTML_BPRE, HTML_EPRE), (_BFACE, EFACE), (_BSIZE, _ESIZE), es mejor explicitarlas en sentencias printf claramente separadas, porque así se ve más clara en nuestro programa en C, el símil de lo que se espera que ocurra en el documento HTML.
Además hay que tener cuidado de anidar correctamente los pares que se corresponden.

Por ejemplo, si abrimos con _BFACE y luego con _BSIZE, primero tenemos que cerrar este último, con  _ESIZE, para luego cerrar el primero _EFACE.

Aquí va el programa:

HTMLHolaMundo.c


#include <stdio.h>

/* Macros para generar salida HTML */

#define HTML_BPRE "<pre>"
#define HTML_EPRE "</pre>"

#define _BOLD(X)  "<b>" X "</b>"
#define _ITALIC(X) "<i>" X "</i>"
#define _UNDERLINE(X) "<u>" X "</u>"
#define _COLOR(C, X) "<font color=" C ">" X "</font>"
#define _FACE(F, X) "<font face=" F ">" X "</font>"
#define _SIZE(S, X) "<font size=" S ">" X "</font>"

#define _URL(L, X) "<a href=" L ">" X "</a>"

#define _BFACE(F) "<font face=" F ">"
#define _EFACE    "</font>"
#define _BSIZE(S) "<font size=" S ">"
#define _ESIZE    "</font>"

#define _LT    "&lt;"
#define _GT    "&gt;"
#define _AMP   "&amp;"
#define _QUOTE "&quot;"

/* */

int main(void) {   
/* Inicia modo PREformateado de HTML */
  printf(HTML_BPRE); 
/* Inicia fuente Arial para todo el documento HTML */
  printf(_BFACE("\"Arial\""));
 
  printf(_COLOR("\"blue\"", _BOLD("¡Hola Mundo HTML desde C!\n\n") ) );
  printf("* " _UNDERLINE("Ejemplo de efecto:") "  " _COLOR("\"blue\"", "¡Hola mundo!\n\n") );
  printf(_COLOR("\"blue\"", _UNDERLINE(_BOLD("* Ejemplo de negrita, subrayado, en color rojo.\n\n"))));
  printf(_URL("\"http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248\"", "Programación en C: curso online"));
 
/* Cierra fuente Arial del documento HTML */
  printf(_EFACE);
/* Cierra modo PREformateado de HTML */
  printf(HTML_EPRE);
}




Ahora bien, para "correr" este programa, tenemos que proceder de modo algo distinto que hasta ahora.
Dado que queremos visualizarlo como documento HTML, tendremos que dar otros pasos, así:

(1) En nuestro IDE, escribir el programa anterior, guardarlo, y finalmente compilarlo, pero sin ejecutarlo.
(2) Abrir la ventana de comandos con CMD.
(3) Ingresar en línea de comandos a la carpeta donde guardamos nuestros proyectos de C (en el post anterior se dan indicaciones de esto, por las dudas).
(4) Allí, ejecutar el programa HTMLHolaMundo.exe, que recién hemos compilado, pero con la salida redirigida a un archivo de extensión .HTML, por ejemplo: OUTPUT.HTML (el nombre es el que más nos guste). Para lograr esto, poner en línea de comandos esto:

HTMLHolaMundo > OUTPUT.HTML

(5) Por último, abrir el documento HTML recién creado. Esto es fácil desde línea de comandos, tipeando:

OUTPUT.HTML

seguido de la teclar Enter, se abrirá el navegador automáticamente con el resultado.

Veremos que el HTML resultante tiene algunos resaltados, colores e incluso un enlace a la web de nuestro curso de C.



Podríamos automatizar esto con el proceso por lotes del post anterior.
Yo lo probé, y funciona bien.
Pero no es adecuado, porque ahora toda la preparación adecuada del resultado esperado para HTML lo hemos puesto ya dentro de nuestro programa, con sumo cuidado.
Así que podemos usar un proceso por lotes más sencillo, que simplemente nos reúna los dos pasos anteriores en uno, así:

eyver.bat (eyver significa: "Ejecutar y ver").

%1.exe > %1.HTML
%1.HTML


Este proceso por lotes espera que le pasemo como parámetro el nombre de nuestro programa, aunque sin la extensión .EXE.

Luego, reemplaza ese nombre en todas las ocurrencias del parámetro %1.
Si hiciéramos:

eyver HTMLHolaMundo

eso sería equivalente a las siguientes dos instrucciones de línea de comandos:

HTMLHolaMundo.exe > HTMLHolaMundo.HTML
HTMLHolaMundo.HTML


O sea que se genera una página HTML con el mismo nombre de nuestro programa, y esto es apropiado porque así tendremos más clara la procedencia de ese archivo HTML.



En el próximo post procuraremos hacer que todo esto sea opcional.
Es decir, no ya hacer un programa para salida a consola, un programa para salida a HTML, y otro para salida a cualquier otra cosa.
Sino que con macros sólidamente definidas, y un adecuado uso de la compilación condicional, vamos a poder tener varias opciones a mano, según las necesidades que nos surjan.






Organización

Comentarios y Consultas

En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Conectado Conectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.275

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #3 : 12/01/2013, 02:51:49 pm »

Macros para Redirigir salida a diversos formatos (parte I)

Las macros del post anterior sólo sirven en el caso de que queramos, sí o sí, tener una salida para HTML.
Pero puede que nos interese jugar con distintos formatos de salida, por ejemplo, la ventana de comandos común y corriente, un archivo HTML con muchos formatos, un archivo HTML sin modificaciones de formato, un documento en Latex, un post del foro, y dejar la puerta abierta a otras posibilidades.

Lo que vamos a hacer será un conjunto de macros para cada caso en particular.
Luego, haremos uso de la compilación condicional con la directiva #if.

Las macros serán las mismas, salvo que agregaremos algunas para caracteres especiales, ya que Latex es más quisquilloso con esto.

Otra modificación es que no obligaremos más al programador a respetar el doble entrecomillado para formatos de HTML.
Esto lo hacemos por una simple razón: Ni la ventana de comandos, ni Latex, ni los posts del foro, entenderán correctamente el doble entrecomillado.

Y no quisiéramos tener que poner separar en diversos casos, según el formato que elijamos,
sino que preferimos dejar sin cambios todo lo que va dentro del bloque main(void) { ...}, y tan sólo tocar una constante que nos permite elegir el tipo de salida, y que todo funcione de maravillas.  :beso:

Eso es una buena compilación condicional. ¿No?  :beso:

Además, para facilitar este reemplazo automático, se han agregado un par de macros más:

#define B_OUTPUT printf( "algo-que-inicializa-la-salida-de-datos" ) 
#define E_OUTPUT printf( "algo-que-finaliza-la-salida-de-datos" )


En HTML, tal como lo venimos usando, esas macros se definirán para manejas las etiquetas <pre> </pre>.
Para LaTeX, la primera macro pondrá todo un largo preámbulo, incluyendo el \begin{document}, mientras que la segunda cerrará el documento con \end{document}
Para los posts del foro, ahí podemos poner cualquier cosa, incluso nada.
Pero yo he elegido poner separadores de línea [hr], el título del programa con resaltados en azul y subrayados, y un spoiler que contendrá la salida del programa.
Por último, si sólo nos interesa una salida normal a la ventana de comandos, la macro B_OUTPUT no tiene que hacer nada, mientras que E_OUTPUT la he elegido para que haga un getchar(), frenando la ejecución, y esperando que el usuario presione ENTER.

Como se ve, para cada caso puede ser interesante configurar los comandos de inicio y final de la salida del programa.



Macros para salida a HTML:

Las de siempre, con unos pocos agregados:



    #define HTML_BPRE "<pre>"
    #define HTML_EPRE "</pre>"
   
    #define B_OUTPUT printf(HTML_BPRE) 
    #define E_OUTPUT printf(HTML_EPRE)
   
    #define _BOLD(X) "<b>" X "</b>"
    #define _ITALIC(X) "<i>" X "</i>"
    #define _UNDERLINE(X) "<u>" X "</u>"
    #define _COLOR(C, X) "<font color=\"" C "\">" X "</font>"
    #define _FACE(F, X) "<font face=\"" F "\">" X "</font>"
    #define _SIZE(S, X) "<font size=" S ">" X "</font>"
   
    #define _URL(L, X) "<a href=\"" L "\">" X "</a>"
   
    #define _BFACE(F) "<font face=\"" F "\">"
    #define _EFACE    "</font>"
    #define _BSIZE(S) "<font size=" S ">"
    #define _ESIZE    "</font>"
   
    #define _LT    "&lt;"
    #define _GT    "&gt;"
    #define _AMP   "&amp;"
    #define _QUOTE "&quot;"
    #define _POUND "#"
    #define _UNDERSCORE "_"


Vemos que ahora, por ejemplo, para la macro _FACE, no hace falta el doble entrecomillado, porque las comillas adicionales que hacen falta para HTML están puestas ahí mismo.
Lo mismo para los demás casos que precisaban entrecomillado doble.
Ahora podemos usarlas en forma sencilla:

_FACE("Arial", "Hola mundo")
_URL("www.rinconmatematico.com/foros", "Foros de matemática")


Hemos agregado las macros _POUND y _UNDERLINE, para los caracteres especiales # y _,
porque esos caracteres requieren un tratamiento especial en Latex.

Uno podría pensar que no hace falta definir unas macros que no necesitamos, ya que en HTML no hacen falta.
Pero la idea es que si quisiéramos cambiar a LaTeX, entonces no tendríamos que hacer otro programa, sino sólo tocar un parámetro "por ahí".
Para eso, es necesario que todas las macros usadas, al fin de formatear la salida a consola, estén definidas en todos los casos.

No obstante, veremos que no es necesario definir estas macros redundantes aquí, y que podemos "olvidarnos" de ellas, sin peligro.



Macros para salida a HTML sin formatos del texto:

Puede que queramos ver la salida del programa como una página web en nuestro navegador, pero que no nos interesen los colorcitos, resaltados, tamaños de fuentes y demás atributos del texto.
En ese caso, nos gustaría generar una salida para HTML, pero sin formatos para el texto,
y basta hacerlo definiendo de distinto modo las mismas macros anteriores, así:



    #define HTML_BPRE "<pre>"
    #define HTML_EPRE "</pre>"
   
    #define B_OUTPUT printf(HTML_BPRE) 
    #define E_OUTPUT printf(HTML_EPRE)
   
    #define _BOLD(X)      X
    #define _ITALIC(X)    X
    #define _UNDERLINE(X) X
    #define _COLOR(C, X)  X
    #define _FACE(F, X)   X
    #define _SIZE(S, X)   X
   
    #define _URL(L, X) "<a href=\"" L "\">" X "</a>"
   
    #define _BFACE(F)     ""
    #define _EFACE        ""
    #define _BSIZE(S)     ""
    #define _ESIZE        ""

    #define _LT    "&lt;"
    #define _GT    "&gt;"
    #define _AMP   "&amp;"
    #define _QUOTE "&quot;"
    #define _POUND "#"
    #define _UNDERSCORE "_"



Por ejemplo, para que no haya formato de "negritas", lo que hace la macro _BOLD(X) es dejar el parámetro X tal como se lo pasaron. Por eso dice así:

    #define _BOLD(X)      X

O sea, no le hace nada a X, y lo manda sin cambios.

Si se fijan bien, he dejado todos los formatos desactivados, menos el de _URL, después de todo, puede ser interesante mantener la funcionalidad de los enlaces webs, que son el corazón de HTML.



Macros para salida a Latex:

Ahora veamos cómo hacemos con Latex.
Es algo más complicado, debido a la compleja sintaxis de Latex.
Se deben usar comandos que comienzan con \, pero en lenguaje C ese signo se debe indicar doble ("\\") para que se reconozca correctamente como el caracter \, y no como una secuencia de escape.

En algunos casos hay que tener especial cuidado con las llaves.
Por ejemplo, si queremos un texto en color azul en Latex, tenemos que escribir algo así:

{  \color{blue}  Texto en azul  }

También, en el preámbulo hemos puesto los paquetes inputenc, color e hyperref, a fin de que Latex interprete correctamente nuestros caracteres acentuados, las macros que cambian el color, y la macro de enlaces webs.

En cuanto a las macros que cambian el tipo de letra, directamente los he desactivado.
No es tan fácil cambiar la fuente en LaTeX.
Aunque hay un par de comandos \selectfont, \usefont, que hacen el trabajo, hacerlo automáticamente desde unas macros sencillas como las nuestras, puede ser un dolor de cabeza.

Así que nos conformamos con un Latex que siempre tendrá el mismo tipo de letra.

En cuanto al tamaño de letra con _SIZE, no funcionarán los números "1" a "7", que sí funcionarán para HTML y para "el Foro". Sólo lograremos que aparezca ese numerito impreso como un caracter en el texto de salida.

En cambio, sí funcionarán opciones como: "\\tiny", "\\small", "\\normalsize", "\\large", "\\Large", "\\LARGE", "\\huge", "\\Huge".

Hay una manera de rodear este inconveniente con más macros... pero por ahora lo voy a dejar así.


    #define LATEX_BDOC \
        "\\documentclass[a4paper]{article}\n\n" \
        "\\usepackage[latin1]{inputenc}\n\n" \
        "\\usepackage{amsmath, amsfonts, amssymb, latexsym}\n\n" \
        "\\usepackage{color}\n\n"  \
        "\\usepackage{hyperref}\n\n"  \
        "\\begin{document}\n\n"
    #define LATEX_EDOC "\n\n\\end{document}\n\n"
   
    #define B_OUTPUT printf(LATEX_BDOC) 
    #define E_OUTPUT printf(LATEX_EDOC) 
   
    #define _BOLD(X) "\\textbf{" X "}"
    #define _ITALIC(X) "\\textit" X "}"
    #define _UNDERLINE(X) "\\underline{" X "}"
    #define _COLOR(C, X) "{\\color{" C "}" X "}"
    #define _FACE(F, X) X
    #define _SIZE(S, X) "{ {" S "}" X "}"   /* Se espera \\large, etc. */
   
    #define _URL(L, X) "\\href{" L "}{" X "}"

   
    #define _BFACE(F) ""
    #define _EFACE    ""
    #define _BSIZE(S) "" S                  /* Sepera \\large, etc. */
    #define _ESIZE    ""
   
    #define _LT    "\\ensuremath{<}"
    #define _GT    "\\ensuremath{>}"
    #define _AMP   "\\&"
    #define _QUOTE "\'\'"
    #define _POUND "\\#"
    #define _UNDERSCORE "\underline{\\ }"
   






Macros para salida al formato del foro de rinconmatematico.com:

Si queremos mostrar el resultado de nuestro programa en el foro, que tiene los comandos que ya conocemos de la caja de edición de texto, y que son generados por sus botones arriba de ella, y obtener esto de una manera automática, bella, prolija, con colorcitos, y con spoiler y todo, basta que definamos las macros así:


    #define FORO_START \
        "[hr]\n\n" \
        "[u][color=navy][b]" ESTE_PROGRAMA_EXE "[/b][/color][/u]\n\n" \
        "[spoiler=(clic aquí)]\n\n"
    #define FORO_FINISH "\n\n[/spoiler]\n\n[hr]\n\n"
   
    #define B_OUTPUT printf(FORO_START)
    #define E_OUTPUT printf(FORO_FINISH)
   
    #define _BOLD(X) "[b]" X "[/b]"
    #define _ITALIC(X) "[i]" X "[/i]"
    #define _UNDERLINE(X) "[u]" X "[/u]"
    #define _COLOR(C, X) "[color=" C "]" X "[/color]"
    #define _FACE(F, X) "[font=" F "]" X "[/font]"   
    #define _SIZE(S, X) "[size=" S "pt]" X "[/size]"
   
    #define _URL(L, X) "[url=http://" L "]" X "[/url]"
   
    #define _BFACE(F) "[font=" F "]"   /* No funciona bien en ciertos casos */
    #define _EFACE    "[/font]" 
    #define _BSIZE(S) "[size=" S "pt]" /* No funciona bien en ciertos casos */
    #define _ESIZE    "[/size]"
   
    #define _LT    "<"
    #define _GT    ">"
    #define _AMP   "&"
    #define _QUOTE "\""
    #define _POUND "#"
    #define _UNDERSCORE "_"





Macros para salida normal por pantalla:


Aquí las macros no harán prácticamente nada, salvo dejar sin cambios el mismo parámetro que se les pasa.

Lo único realmente trascendente es que la macro E_OUTPUT, que marca el final de la salida de texto, tendrá ahí un getchar(), que frenará la ejecución antes de terminar.


    #define B_OUTPUT ;
    #define E_OUTPUT getchar()
   
    #define _BOLD(X)      X
    #define _ITALIC(X)    X
    #define _UNDERLINE(X) X
    #define _COLOR(C, X)  X
    #define _FACE(F, X)   X
    #define _SIZE(S, X)   X
   
    #define _URL(L, X)    "(" L "): " X
   
    #define _BFACE(F)     ""
    #define _EFACE        ""
    #define _BSIZE(S)     ""
    #define _ESIZE        ""
   
    #define _LT    "<"
    #define _GT    ">"
    #define _AMP   "&"
    #define _QUOTE "\""
    #define _POUND "#"
    #define _UNDERSCORE "_"
   


Hemos dejado que la macro _URL muestre ambas cosas: la dirección web, y el texto del enlace.



Poniendo todas las opciones juntas.

Ahora vamos a agregar la compilación condicional.

Primero declaramos estas constantes, una para cada caso de los referidos:


#define OUTPUT_STD  0
#define OUTPUT_HTML 1
#define OUTPUT_ONLYPREHTML 2
#define OUTPUT_LATEX 3
#define OUTPUT_FORO  4



Además, vamos a declarar la macro OUTPUT_MODE, a la cual le asignaremos un número, según el formato de salida que más nos guste, por ejemplo, consola:

#define OUTPUT_MODE OUTPUT_STD

Podría pasar que nos olvidemos de definir esta constante.
Para no caer en esa situación incómoda (que impediría que el programa compile bien),
tendríamos que preguntar si la macro OUTPUT_MODE está definida o no.

Para eso se usan las directivas de preprocesador #ifdef y #ifndef. Ambas funcionan de modo muy similar a #if, salvo que preguntan si una macro está definida o no en nuestro programa.

#ifdef MACRO: pregunta si la la macro con nombre MACRO ha sido definida hasta el punto del archivo en que se hace la consulta.
#ifndef MACRO: pregunta si la la macro con nombre MACRO aún no ha sido definida hasta el punto del archivo en que se hace la consulta.

En caso de que OUTPUT_MODE no esté definida, forzaremos su definición al valor por defecto OUTPUT_STD.


#ifndef OUTPUT_MODE
  #define OUTPUT_MODE   OUTPUT_STD
#endif


Podemos también usar #ifndef para preguntar si alguna de las macros de formato han quedado sin definir.
En caso de que hayamos "olvidado" definir alguna, le daremos algún valor por defecto, por ejemplo, el que tendrían para la salida estándar, caso OUTPUT_STD.
Lo que haremos será, tediosamente, preguntar por cada una de ellas, e ir dando una definición, en caso de ausencia, así:



#ifndef B_OUTPUT
    #define B_OUTPUT ;
#endif

#ifndef E_OUTPUT
    #define E_OUTPUT ;
#endif
   
#ifndef _BOLD
    #define _BOLD(X)      X
#endif

#ifndef _ITALIC
    #define _ITALIC(X)    X
#endif

#ifndef _UNDERLINE
    #define _UNDERLINE(X) X
#endif

#ifndef _COLOR
    #define _COLOR(C, X)  X
#endif

#ifndef _FACE
    #define _FACE(F, X)   X
#endif

#ifndef _SIZE
    #define _SIZE(S, X)   X
#endif

   
#ifndef _URL
    #define _URL(L, X)    "(" L "): " X
#endif

   
#ifndef _BFACE
    #define _BFACE(F)     ""
#endif

#ifndef _EFACE
    #define _EFACE        ""
#endif

#ifndef _BSIZE
    #define _BSIZE(S)     ""
#endif

#ifndef _ESIZE
    #define _ESIZE        ""
#endif

   
#ifndef _LT
    #define _LT    "<"
#endif

#ifndef _GT
    #define _GT    ">"
#endif

#ifndef _AMP
    #define _AMP   "&"
#endif

#ifndef _QUOTE
    #define _QUOTE "\""
#endif

#ifndef _POUND
    #define _POUND "#"
#endif

#ifndef _UNDERSCORE
    #define _UNDERSCORE "_"
#endif






El programa principal intentará cargar la fuente Arial, mostrar el mensaje "Hola mundo" en azul, y debajo una prueba de opciones de formato, así como de los caracteres especiales.

Se usarán las macros B_OUTPUT para la gestión de operaciones de inicio de salida en el formato elegido, y E_OUTPUT para gestionar el fin de la salida de datos. Tienen que ir justo al principio y el final del programa, para que tenga el significado correcto.

Si usamos las macros con cuidado dentro del bloque main(void) {  ...  },
teniendo cuidado de usar las macros para los caracteres especiales < > & " # _
en vez de escribirlos directamente, vamos a lograr que el programa funcione correctamente, sin novedad alguna, para todos los valores posibles de OUTPUT_MODE.

He aquí el programa completo:

OutputHolaMundo.c



#include <stdio.h>

#define OUTPUT_STD  0
#define OUTPUT_HTML 1
#define OUTPUT_ONLYPREHTML 2
#define OUTPUT_LATEX 3
#define OUTPUT_FORO  4


#ifndef OUTPUT_MODE
  #define OUTPUT_MODE  OUTPUT_STD
#endif

/* Macros para generar salida formateada de diversas maneras */

#if (OUTPUT_MODE == OUTPUT_HTML)
    #define HTML_BPRE "<pre>"
    #define HTML_EPRE "</pre>"
   
    #define B_OUTPUT printf(HTML_BPRE) 
    #define E_OUTPUT printf(HTML_EPRE)
   
    #define _BOLD(X) "<b>" X "</b>"
    #define _ITALIC(X) "<i>" X "</i>"
    #define _UNDERLINE(X) "<u>" X "</u>"
    #define _COLOR(C, X) "<font color=\"" C "\">" X "</font>"
    #define _FACE(F, X) "<font face=\"" F "\">" X "</font>"
    #define _SIZE(S, X) "<font size=" S ">" X "</font>"
   
    #define _URL(L, X) "<a href=\"" L "\">" X "</a>"
   
    #define _BFACE(F) "<font face=\"" F "\">"
    #define _EFACE    "</font>"
    #define _BSIZE(S) "<font size=" S ">"
    #define _ESIZE    "</font>"
   
    #define _LT    "&lt;"
    #define _GT    "&gt;"
    #define _AMP   "&amp;"
    #define _QUOTE "&quot;"
    #define _POUND "#"
    #define _UNDERSCORE "_"
   
#elif (OUTPUT_MODE == OUTPUT_ONLYPREHTML)
    #define HTML_BPRE "<pre>"
    #define HTML_EPRE "</pre>"
   
    #define B_OUTPUT printf(HTML_BPRE) 
    #define E_OUTPUT printf(HTML_EPRE)
   
    #define _BOLD(X)      X
    #define _ITALIC(X)    X
    #define _UNDERLINE(X) X
    #define _COLOR(C, X)  X
    #define _FACE(F, X)   X
    #define _SIZE(S, X)   X
   
    #define _URL(L, X) "<a href=\"" L "\">" X "</a>"
   
    #define _BFACE(F)     ""
    #define _EFACE        ""
    #define _BSIZE(S)     ""
    #define _ESIZE        ""

    #define _LT    "&lt;"
    #define _GT    "&gt;"
    #define _AMP   "&amp;"
    #define _QUOTE "&quot;"
    #define _POUND "#"
    #define _UNDERSCORE "_"

#elif (OUTPUT_MODE == OUTPUT_LATEX)

    #define LATEX_BDOC \
        "\\documentclass[a4paper]{article}\n\n" \
        "\\usepackage[latin1]{inputenc}\n\n" \
        "\\usepackage{amsmath, amsfonts, amssymb, latexsym}\n\n" \
        "\\usepackage{color}\n\n"  \
        "\\usepackage{hyperref}\n\n"  \
        "\\begin{document}\n\n"
    #define LATEX_EDOC "\n\n\\end{document}\n\n"
   
    #define B_OUTPUT printf(LATEX_BDOC) 
    #define E_OUTPUT printf(LATEX_EDOC) 
   
    #define _BOLD(X) "\\textbf{" X "}"
    #define _ITALIC(X) "\\textit" X "}"
    #define _UNDERLINE(X) "\\underline{" X "}"
    #define _COLOR(C, X) "{\\color{" C "}" X "}"
    #define _FACE(F, X) X
    #define _SIZE(S, X) "{ {" S "}" X "}"   /* Se espera \\large, etc. */
   
    #define _URL(L, X) "\\href{" L "}{" X "}"

   
    #define _BFACE(F) ""
    #define _EFACE    ""
    #define _BSIZE(S) "" S                  /* Espera "\\tiny", "\\large", etc. */
    #define _ESIZE    ""
   
    #define _LT    "\\ensuremath{<}"
    #define _GT    "\\ensuremath{>}"
    #define _AMP   "\\&"
    #define _QUOTE "\'\'"
    #define _POUND "\\#"
    #define _UNDERSCORE "\underline{\\ }"
   

#elif (OUTPUT_MODE == OUTPUT_FORO)

#define ESTE_PROGRAMA_EXE "OutputHolaMundo.exe"

    #define FORO_START \
        "[hr]\n\n" \
        "[u][color=navy][b]" ESTE_PROGRAMA_EXE "[/b][/color][/u]\n\n" \
        "[spoiler=(clic aquí)]\n\n"
    #define FORO_FINISH "\n\n[/spoiler]\n\n[hr]\n\n"
   
    #define B_OUTPUT printf(FORO_START)
    #define E_OUTPUT printf(FORO_FINISH)
   
    #define _BOLD(X) "[b]" X "[/b]"
    #define _ITALIC(X) "[i]" X "[/i]"
    #define _UNDERLINE(X) "[u]" X "[/u]"
    #define _COLOR(C, X) "[color=" C "]" X "[/color]"
    #define _FACE(F, X) "[font=" F "]" X "[/font]"   
    #define _SIZE(S, X) "[size=" S "pt]" X "[/size]"
   
    #define _URL(L, X) "[url=http://" L "]" X "[/url]"
   
    #define _BFACE(F) "[font=" F "]"   /* No funciona bien en ciertos casos */
    #define _EFACE    "[/font]" 
    #define _BSIZE(S) "[size=" S "pt]" /* No funciona bien en ciertos casos */
    #define _ESIZE    "[/size]"
   
    #define _LT    "<"
    #define _GT    ">"
    #define _AMP   "&"
    #define _QUOTE "\""
    #define _POUND "#"
    #define _UNDERSCORE "_"
   

#else
    #define B_OUTPUT ;
    #define E_OUTPUT getchar()
   
    #define _BOLD(X)      X
    #define _ITALIC(X)    X
    #define _UNDERLINE(X) X
    #define _COLOR(C, X)  X
    #define _FACE(F, X)   X
    #define _SIZE(S, X)   X
   
    #define _URL(L, X)    "(" L "): " X
   
    #define _BFACE(F)     ""
    #define _EFACE        ""
    #define _BSIZE(S)     ""
    #define _ESIZE        ""
   
    #define _LT    "<"
    #define _GT    ">"
    #define _AMP   "&"
    #define _QUOTE "\""
    #define _POUND "#"
    #define _UNDERSCORE "_"
   

#endif /* #ifdef */

/* Aquí pescamos las macros que no se han declarado arriba */

#ifndef B_OUTPUT
    #define B_OUTPUT ;
#endif

#ifndef E_OUTPUT
    #define E_OUTPUT ;
#endif
   
#ifndef _BOLD
    #define _BOLD(X)      X
#endif

#ifndef _ITALIC
    #define _ITALIC(X)    X
#endif

#ifndef _UNDERLINE
    #define _UNDERLINE(X) X
#endif

#ifndef _COLOR
    #define _COLOR(C, X)  X
#endif

#ifndef _FACE
    #define _FACE(F, X)   X
#endif

#ifndef _SIZE
    #define _SIZE(S, X)   X
#endif

   
#ifndef _URL
    #define _URL(L, X)    "(" L "): " X
#endif

   
#ifndef _BFACE
    #define _BFACE(F)     ""
#endif

#ifndef _EFACE
    #define _EFACE        ""
#endif

#ifndef _BSIZE
    #define _BSIZE(S)     ""
#endif

#ifndef _ESIZE
    #define _ESIZE        ""
#endif

   
#ifndef _LT
    #define _LT    "<"
#endif

#ifndef _GT
    #define _GT    ">"
#endif

#ifndef _AMP
    #define _AMP   "&"
#endif

#ifndef _QUOTE
    #define _QUOTE "\""
#endif

#ifndef _POUND
    #define _POUND "#"
#endif

#ifndef _UNDERSCORE
    #define _UNDERSCORE "_"
#endif


/* */

int main(void) {   

  B_OUTPUT;                /* Pasos iniciales para el formato de salida elegido */

  printf(_BFACE("Arial"));  /* Intenta iniciar fuente Arial, si están habilitadas las fuentes */
 
  printf(_COLOR("blue", _BOLD("¡Hola Mundo!") ) "\n\n" );
  printf("* " _UNDERLINE("Ejemplo de efecto:") "  " _COLOR("blue", "¡Hola mundo!") "\n\n");
  printf(_COLOR("blue", _UNDERLINE(_BOLD("* Ejemplo de negrita, subrayado, en color azul."))) "\n\n");
  printf("Signos especiales: " _LT " " _GT " " _AMP " " _QUOTE " " _POUND "\n\n");
  printf(_URL("http://rinconmatematico.com/foros/index.php?topic=64835.msg260248" _POUND "msg260248", "Programación en C: curso online"));

  printf(_EFACE);               /* Cierra fuente Arial, si es que había sido iniciada */

  E_OUTPUT;                   /* Realiza operaciones para finalizar la salida en el formato elegido */
}





¿Cómo generar las salidas esperadas, del modo correcto?

Expliquemos cómo hacer para que esto realmente nos dé los resultados que esperamos.

Lo que tenemos que hacer, primero que nada, es crear un proceso por lotes en la ventana de comandos, que vamos a llamar eyv.bat ("ejecutar y ver").

(1) Abramos la ventana de comandos de Windows, y accedamos a la carpeta donde guardamos nuestros proyectos de C.

(2) Creemos allí el archivo por lotes eyv.bat (ya sea con el programa EDIT, o alguna otra forma), con el siguiente contenido:

%1.EXE > %1.%2
%1.%2


¿Qué hace eso? Lo explicamos en el spoiler:

Spoiler (click para mostrar u ocultar)

(3) En nuestro IDE wxDev-C++, carguemos o escribamos el programa OutputHolaMundo.c, con todas las macros ya explicadas.

(4) Editemos la línea que define la constante OUTPUT_MODE, poniendo la opción que nos interese, de las 5 disponibles.

(5) Compilemos el programa, pero sin ejecutarlo.

(6) Volvamos a la ventana de comandos, y ejecutemos el proceso por lotes eyv.bat, de alguna de las siguientes manersa, según la opción de salida que hayamos escogido al compilad, así:

EYV   OutputHolaMundo   HTML                 (si elegimos OUTPUT_HTML, o OUTPUT_ONLYPREHTML)
EYV   OutputHolaMundo   TEX                 (si elegimos OUTPUT_LATEX)
EYV   OutputHolaMundo   TXT                 (si elegimos OUTPUT_FORO)

(7) En caso de que no hayamos elegido ninguna de esas opciones, y optamos por OUTPUT_STD, no tenemos que usar el proceso por lotes EYV, sino que debemos realizar la ejecución directa del programa, así:

OutputHolaMundo



En el caso de HTML, se nos abrirá nuestro navegador por defecto, mostrando el archivo OutputHolaMundo.HTML.

En el caso de LATEX, se nos abrirá nuestro editor de LaTeX por defecto, cargando automáticamente el archivo OutputHolaMundo.TEX.
Allí podremos realizar lo que queramos con el documento de LaTeX, en particular podemos compilarlo con PDFLATEX para generar un documento PDF de Acrobat Reader, que mantendrá y mostrará adecuadamente todos los resaltados, así como los enlaces URL.

En el caso de TXT, se nos abrirá el Bloc de Notas de Windows con el contenido generado por el programa OutputHolaMundo.exe.
Para poder usar esto en el foro, basta conque copiemos todo el texto del archivo TXT al portapapeles, y lo peguemos en la caja de edición, mientras estamos escribiendo un post en el foro de rinconmatematico.

En el caso de la consola estándar, no podemos hacer nada, claro, salvo ver cómo la información del programa pasa por delante de nuestros ojos.



Consideraciones finales.

Todo esto de la salida formateada a diversos modos distintos, obviamente que es una forma opcional de trabajar.

Si estamos cómodos con la línea de comandos, o si conocemos mejores maneras de mostrar los resultados de un programa ejecutable de C, todo esto no nos hace falta.

Creo, sin embargo, que ha sido todo esto una buena excusa para aprender cosas sobre las directivas del preprocesador, las macros y la compilación condicional.

Vemos que puede hacerse mucho aún con ellas, sin siquiera habernos metido en las mínimas complejidades de la programación en C.

Por otra parte, si nos interesa utilizar estas macros en todos nuestros programas, entonces estamos en un pequeño aprieto, porque al tener que agregarlas siempre, los programas nos quedarán largos de entrada, aún cuando sólo muestren un "Hola Mundo".
Cuando este tipo de cosas comienzan a ocurrir, lo que se acostumbra hacer es tomar todas las definiciones que pretendemos reutilizar una y otra vez, y ponerlas todas juntas en un archivo aparte, con extensión .h.
Así, creamos un archivo de librería propio.
Luego, se incluiría en los futuros programas con una directiva #include, y listo.

No obstante, esto no lo haré aquí, y se postergará, quizá, hasta un futuro capítulo en que desarrollemos la teoría formal completa de cómo funciona el preprocesador.





Organización

Comentarios y Consultas
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Conectado Conectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.275

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #4 : 12/01/2013, 03:28:30 pm »

Macros para Redirigir salida a diversos formatos (parte II)


Les mostraré el resultado de las pruebas que hice en mi computadora.

Prueba 1:

En el fuente:

#define  OUTPUT_MODE  OUTPUT_HTML

En el IDE: Compilar.

En línea de comandos:

EYV  OutputHolaMundo  HTML

Se abrió mi navegador mostrando:





Prueba 2:

En el fuente:

#define  OUTPUT_MODE  OUTPUT_ONLYPREHTML

En el IDE: Compilar.

En línea de comandos:

EYV  OutputHolaMundo  HTML

Se abrió mi navegador mostrando:




Prueba 3:

En el fuente:

#define  OUTPUT_MODE  OUTPUT_LATEX

En el IDE: Compilar.

En línea de comandos:

EYV  OutputHolaMundo  TEX

Se abrió mi editor de Latex mostrando:


El contenido del archivo .tex lo pongo en spoiler:

Spoiler (click para mostrar u ocultar)

Compilé ese documento Latex con PDFLATEX.
Me generó un archivo PDF, que abrí con Adobe Acrobat Reader,
y me mostró este contenido:




Prueba 4:

En el fuente:

#define  OUTPUT_MODE  OUTPUT_FORO

En el IDE: Compilar.

En línea de comandos:

EYV  OutputHolaMundo  TXT

Se abrió mi editor de texto mostrando:


El contenido del archivo .txt lo pongo acá:

[hr]

[u][color=navy][b]OutputHolaMundo.exe[/b][/color][/u]

[spoiler=(clic aquí)]

[font=Arial][color=blue][b]¡Hola Mundo![/b][/color]

* [u]Ejemplo de efecto:[/u]  [color=blue]¡Hola mundo![/color]

[color=blue][u][b]* Ejemplo de negrita, subrayado, en color azul.[/b][/u][/color]

Signos especiales: < > & " #

[url=http://http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248]Programación en C: curso online[/url][/font]

[/spoiler]

[hr]



El resultado de postear eso en el foro es esto:

*******************************************************



OutputHolaMundo.exe

Spoiler: (clic aquí) (click para mostrar u ocultar)



*******************************************************




Prueba 5:

En el fuente:

#define  OUTPUT_MODE  OUTPUT_STD

En el IDE: Compilar.

En línea de comandos:

OutputHolaMundo

Lo que me muestra la ventana de comandos es esto:


El texto de salida lo copio en spoiler:

Spoiler (click para mostrar u ocultar)




Me aplaudo yo solo.  Aplauso





Organización

Comentarios y Consultas

* 20130112outputholamundo-latex.png (82.31 KB - descargado 422 veces.)
* 20130112outputholamundo-pdf.png (51.69 KB - descargado 388 veces.)
* 20130112outputholamundo-txt.png (25.61 KB - descargado 406 veces.)
* 20130112outputholamundo-std.png (30.81 KB - descargado 438 veces.)
* 20130112outputholamundo-html.png (35.38 KB - descargado 404 veces.)
* 20130112outputholamundo-onlyprehtml.png (32.15 KB - descargado 379 veces.)
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Conectado Conectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.275

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #5 : 12/01/2013, 04:47:40 pm »

Macros para Redirigir salida a diversos formatos (parte III)



Aquí vamos a volver a realizar los programas que testeaban tipos enteros de C, pero ahora con la salida formateada con las opciones desarrolladas en el post anterior.

No voy a entrar en muchos detalles, porque ya me imagino que el público está cansado de esto.
He modificado las macros que generaban los análisis de los tipos enteros, a fin de que ahora tengan colorcitos, negritas, etc.
También he agregado atributos de ese tipo a varios de los mensajes que directamente estaban escritos con printf.

Por supuesto, he agregado (con un simple "copiar y pegar") las macros de formato que creamos en el post anterior.

Al aplicar estos cambios a los programas TestingIntegers1.c y TestingIntegers2.c, se obtuvieron dos programas, ahora con nombres OutputTestingIntegers1.c y OutputTestingIntegers2.c.
Debido a que han quedado muy extensos, y básicamente son lo mismo que antes, salvo que con el formato de salida cambiado (en particular he elegido HTML), no los voy a transcribir directamente aquí.

Por otra parte, el uso de etiquetas del foro dentro de esos programas trae algunos inconvenientes cuando quiero ponerlos en un Spoiler. (Se puede solucionar, pero tendría que agregar extrañas cosas ilegibles en los programas C).

Así que directamente se los voy a dejar colgados como partes de un archivo adjunto comprimido ZIP.
Además, si tienen curiosidad por ver el resultado de la salida, sin tomarse el trabajo de compilar y ver qué pasa, les dejo adjuntos también dos archivos HTML, con las salidas de ambos programas.
A ver si con eso los entusiasmo para hacer este tipo de cosas con C.

Sólo una aclaración: En el 2do programa he querido mostrar el símbolo [texx]\leq[/texx], que en HTML se logra subrayando un signo <, que a su vez es un caracter especial, que requiere mejor imprimirlo mediante la macro _LT (del post anterior), que genera el código HTML &lt;.
Esto se haría, pues, mediante _UNDERLINE(_LT), que a su vez le he puesto un nombre: la macro _LESSTHAN, que verán ustedes repartida varias veces en el programa.



Pongamos, pues, punto final a este asunto.





Organización

Comentarios y Consultas

* OutputTestingIntegers1y2.zip (8.82 KB - descargado 144 veces.)
* OutputTestingIntegers1.HTML (24.57 KB - descargado 265 veces.)
* OutputTestingIntegers2.HTML (16.99 KB - descargado 246 veces.)
En línea

Páginas: [1]   Ir Arriba
  Imprimir  
 
Ir a:  

Impulsado por MySQL Impulsado por PHP Powered by SMF 1.1.4 | SMF © 2006, Simple Machines LLC XHTML 1.0 válido! CSS válido!