Cómo escribir un programa de calendario perpetuo en lenguaje C

#define ENTER 0x1C0D /* Ingresar clave */

int año, mes, día

static char *days[8] = {" ", "Domingo", "Lunes", "Martes","

"Miércoles", "Jueves", "Viernes", "Sábado"};

struct TIMEDATE {

int año; /* año 1980..2099 */

int mes; /* mes 1=enero 2=febrero, etc.*/

int día; /* día del mes 0...31 */

int horas; /* hora 0...23 */

struct TIMEDATE {

struct FECHAHORA {

struct FECHAHORA {

struct FECHAHORA {

int minutos /* minuto 0..59 */

int segundos; ; /* segundo 0...59 */

int hsecs; /* 1/100 segundo 0.99 */

char dateline[47] /* fecha y hora juntos; */

char dateline[47] /* fecha y tiempo juntos */

fecha y tiempo juntos */

}; >

estructura estática HORA hoy

main()

{

char cmonth[3]

char cday[ 3];

char cyear[5];

doble getdays();

doble día entumecido, entumecido

int día laborable, retcode, día, i;

día y hora(amp.today);

clrscn();

for (i=0; ilt; 3; i)cmes[i]='\0';

para (i=0; ilt; 3; i)cdía[i]='\0'; i=0; ilt; 5; i)cyear[i]='\0';

putstr(5, 8, 14, "Ingrese la fecha en formato MM DD AAAA:"); p >

mientras (recodificar! = ENTER)

{

retcode = bufinp(5, 41, 13, 2, cmonth

if (retcode ! = ENTER) retcode = bufinp (5,44,13,2,cdía);

if (retcode ! = ENTER) retcode = bufinp(5, 47, 13, 4, caño);

}

año = atoi(amp; caño);

mes = atoi(amp; cmes);

día = atoi(amp. cday); día);

entumecido = getdays(hoy.año, hoy.mes, hoy.día

día de la semana = días de la semana(día entumecido); numbnow - daynumb == 0)

printf("/n\n02d-02d-d es", mes, día, año

if (numbnow - daynumb gt; 0) )

printf("/n\n02d-02d-d era", mes, día, año

if (numbnow - daynumb lt; 0)

printf("\n\n02d-02d-d será", mes, día, año);

printf(" a s\n", días[día de la semana]

}/* end MAIN */

/**** ************************************************** * ******

* GETDAYS - Esta subrutina devuelve un *

* basado en el valor entero del año (AAAA), mes *

* día ( DD) Un número doble de punto flotante que representa el *

* número de días desde el 1 de enero de 1980 (día 1).

*Esta rutina es lo opuesto a GETDATE.

******************************************* *******************/

double getdays(año, mes, día)

int año, mes, día;

{

int y, m;

doble a, b, d, día entumecido; intg();

doble piso(), intg();

/*************************** **** ****

** Corrección sin año 0 **

******************** **** **********/

if (año lt; 0) y = año 1

else y = año

/ ********************************************** ***** *******

** En este cálculo, enero y febrero son los meses 13 y 14**

******* * ************************************************* /

m = mes;

if (mes lt; 3)

{

m = m 12;

y = y - 1

}

/*************************** *

** Calcular el día juliano**

********************** **/

d = piso(365.25 * y) intg(30.6001 * (m 1)) día - 723244.0

/*****************; * *******************************

** Si antes del 5 de octubre de 1582, entonces utiliza el juliano calendario**

************************************* **** ******/

if (d lt; -145068.0) daynumb = d

/ ************ ****; *******************

**En caso contrario, utilice el calendario gregoriano**

**** **** *****************************/

más

{

a = piso(y / 100.0);

b = 2 - a piso(a / 4.0

daynumb = d b;

return(daynumb);

}/* Fin GETDAYS */

/************ **** *******************

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

* GETDATE - Esta rutina obtiene un número de punto flotante doble*

* * Representa el número de días desde el 1 de enero de 1980 (día 1) y devuelve el año, mes, *

* día*

* Este ejemplo Cheng es lo opuesto a GETDAYS *

**************************************** **** **************/

getdate(entumecido)

doble entumecido

{

p>

doble a, aa, b, c, d, e, z;

fecha doble

fecha = entumecido

z = intg(fecha 2444239.0);

if (fecha lt; - 145078.0) a = z

en caso contrario

{

aa; = piso((z - 1867216.25) / 36524.25);

a = z 1 aa - piso(aa/4.0);

}

b = a; 1524,0 ;

c = intg((b - 122,1) / 365,25);

d = intg(365,25 * c); = intg((b - d) / 30.6001);

día = b - d - intg(30.6001 * e);

if (e gt.13.5) mes = e - 13,0 ;

más mes = e - 1,0

si (mes gt; 2) año = c - 4716,0

más año = c - 4715,0;

if (año lt; 1) - año;

return

}/* Fin GETDATE */

/** * ************************************************* ** ***

* DÍAS DE LA SEMANA - Esta rutina obtiene un doble flotante *

* que representa el número de días desde el 1 de enero de 1980 (día 1) y devuelve la semana El día de *

* donde 1 = domingo, 2 = martes, etc.

******************************************* ************/

int días laborables(entumecido)

doble entumecido

{

doble dd;

int día

dd = entumecido

mientras (dd gt; 28000.0) dd = dd - 28000.0; p> while (dd lt; 0) dd = dd 28000.0;

día = dd

día = ((día 1) 7)

retorno(día);

}

/****************************** ***** ****************************

*FRACT - Esta rutina recibe un número de coma flotante doble *

* y devuelve la parte decimal como doble*

* Devuelve un número de coma flotante*

*********** * ******** **********************************/

doble frac(entumecido)

doble entumecido

{

int inumb;

doble fnumb; p>

doble fnumb ); (int inumb;

doble fnumb)

mientras (numb lt; -32767) entumecido = 32767

mientras (entumecido gt; 32767) entumecido -= 32767;

inumb = entumecido;

fnumb = inumbido

return(num-fnumb); >

}/* Fin FRACT */

/********************************* ******* *******************

*PISO - Esta rutina recibe un doble flotador*

* y devuelve el siguiente entero más pequeño*

************************************* **** ****************/

doble piso(adormecido)

doble entumecido

{

doble fract(), intg();

doble salida;

salida = intg(numb); entumecido lt 0 amp; frac(adormecido) ! = 0) fuera -=

1.0;

retorno(salida);

}/* final PISO */

/*************** **************************************

*INTG- Esta rutina toma un doble flotante*

* y devuelve la parte entera como un doble flotante*

* un flotante*

*** **** *********************** **************************** ***/

doble intg(entumecido)

doble entumecido

{

doble frac();

return(entumecido - fract(entumecido ));

}/* Fin INTG */