API tools faq
paste
Advertisement
hpolzer

Church Holidays

hpolzer
Sep 23rd, 2023
1,014
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.72 KB | Source Code | 0 0
raw download clone embed print report
  1. /***************************************************************************************
  2. *   This program (ANSI C) computes the dates of the most important
  3. *   Catholic church holidays, additionally gives Orthodox Easter and
  4. *   Christmas dates, computes the Protestant "Buss- und Bettag" and
  5. *   outputs the results as a list of CSV. This program contains no
  6. *   safety measures and implements only a rudimentary error handling.
  7. *
  8. *   Compile:    gcc -ansi -pedantic -O3 -o kft kft.c
  9. *   Invoke:     kft [year] [year]   (kft=Kirchliche FeierTage)
  10. *   Bug:        See commentary on "int jahr_aus_systemdatum (void)"
  11. *   Last change:    September 16th, 2023.
  12. *   Copyright (C) <December 3rd, 2015> Henning POLZER,
  13. *   send comments and error reports to: h underscore polzer at gmx dot de.
  14. *
  15. *   This program is free software; you can redistribute it and/or
  16. *   modify it under the terms of the GNU General Public License
  17. *   as published by the Free Software Foundation; either version 2
  18. *   of the License, or (at your option) any later version.
  19. *
  20. *   This program is distributed in the hope that it will be useful,
  21. *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23. *   GNU General Public License for more details.
  24. *
  25. *   You should have received a copy of the GNU General Public License
  26. *   along with this program; if not, write to the Free Software
  27. *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  28. ***************************************************************************************/
  29.  
  30.             /* Erforderlich fuer: */
  31. #include <math.h>   /* floor() */
  32. #include <stdio.h>  /* printf() */
  33. #include <stdlib.h> /* atoi() */
  34. #include <time.h>   /* time() */
  35.  
  36. #define GRENZE 5000 /* Obere Jahresgrenze fuer Berechnungen */
  37.  
  38. typedef unsigned int ganz; /* 0..maxint; der Kuerze halber "ganz" */
  39.  
  40. typedef struct  {
  41.             ganz t,m,j; /* Tag, Monat, Jahr */
  42.         } datum; /* Wichtigster Variablentyp des gesamten Programms */
  43.  
  44. /*
  45.     Die Variable "ks" steht fuer "KalenderStil" und erhaelt die Werte
  46.     1 fuer den julianischen und
  47.     2 fuer den gregorianischen
  48.     Kalender. Die Vereinbarung erfolgt aber nicht hier, sondern jeweils
  49.     lokal in den Funktionen.
  50. */
  51.  
  52.  
  53. /***********************************************************************
  54. *   Prueft, ob das uebergebene Jahr ein Schalt- oder Gemeinjahr im
  55. *   julianischen bzw. gregorianischen Kalender ist. Die Funktion
  56. *   liefert als Fehlerwert -1 zurueck, falls das nicht existente
  57. *   Jahr 0 uebergeben wurde und ist deshalb vorzeichenbehaftet.
  58. *   (Dieses Programm (kft.c) wertet den moeglichen Fehlerwert
  59. *   allerdings nicht aus, weil schon das Hauptprogramm prueft, ob
  60. *   sich die Jahresgrenzen im erlaubten Bereich >0 bewegen. Der
  61. *   Fehlerwert bleibt hier nur zur Erhaltung der universellen
  62. *   Verwendbarkeit der Funktion erhalten.)
  63. ************************************************************************/
  64. int schaltjahr(int stil,int jahr)
  65. {
  66.     ganz j=jahr,schalt=0,ks=stil;
  67.  
  68.     if(j==0) return -1;     /* Fehler: Kein Jahr 0 */
  69.     if(ks==1)           /* julian. Kal. */
  70.       if(j%  4==0) schalt=1;
  71.     if(ks==2) {         /* gregorian. Kal. */
  72.       if(j%  4==0) schalt=1;
  73.       if(j%100==0) schalt=0;
  74.       if(j%400==0) schalt=1;
  75.     } /* if(ks==2) */
  76.     return schalt;
  77. } /* schaltjahr() */
  78.  
  79.  
  80. /*************************************************************
  81. *   Verwandelt gegebenes Tagesdatum in eine laufende Nummer.
  82. *   Mit den Funktionen ganz datum_in_nummer(ganz,datum) und
  83. *   datum nummer_in_datum(ganz,ganz,ganz) kommen die
  84. *   Berechnungen ohne die julianische Tagesnummer aus, das
  85. *   ist (hoffentlich) einfacher verstaendlich.
  86. *   (Ursprungsfassung vom 17.06.2015.)
  87. **************************************************************/
  88. ganz datum_in_nummer(ganz stil,datum tagesdatum)
  89. {
  90.     datum dat=tagesdatum;
  91.     /* Schalttag zur evtl.en Addition bereithalten: */
  92.     ganz ks=stil,schalttag=schaltjahr(ks,dat.j),summe=0;
  93.  
  94.     switch(dat.m) {
  95.       /* Schalttag zunaechst noch unwichtig: */
  96.       case  1: summe=    dat.t;     break;
  97.       case  2: summe= 31+dat.t;     break;
  98.       /* Tagesnr. ab Maerz vom Schalttag beeinflusst: */
  99.       case  3: summe= 59+dat.t+schalttag;   break;
  100.       case  4: summe= 90+dat.t+schalttag;   break;
  101.       case  5: summe=120+dat.t+schalttag;   break;
  102.       case  6: summe=151+dat.t+schalttag;   break;
  103.       case  7: summe=181+dat.t+schalttag;   break;
  104.       case  8: summe=212+dat.t+schalttag;   break;
  105.       case  9: summe=243+dat.t+schalttag;   break;
  106.       case 10: summe=273+dat.t+schalttag;   break;
  107.       case 11: summe=304+dat.t+schalttag;   break;
  108.       case 12: summe=334+dat.t+schalttag;   break;
  109.     } /* switch(dat.m) */
  110.  
  111.     return summe;
  112. } /* datum_in_nummer() */
  113.  
  114.  
  115. /***********************************************************
  116. *   Verwandelt laufende Nummer eines Tages in ein Datum:
  117. *   (Ursprungsfassung vom 17.06.2015.)
  118. ************************************************************/
  119. datum nummer_in_datum(ganz stil,ganz tagesnummer,ganz jahreszahl)
  120. {
  121.     ganz    ks=stil,nr=tagesnummer,tag=0,monat=0,
  122.         jahr=jahreszahl,schalttag=schaltjahr(ks,jahr);
  123.     datum   tempdatum;
  124.  
  125.      /* Jahr kann schon hier zugewiesen werden: */
  126.     tempdatum.j=jahr;
  127.  
  128.     if(schalttag==0) {
  129.       if((nr>=  1)&&(nr<= 31)) { tag=nr;     monat= 1; }
  130.       if((nr>= 32)&&(nr<= 59)) { tag=nr- 31; monat= 2; }
  131.       if((nr>= 60)&&(nr<= 90)) { tag=nr- 59; monat= 3; }
  132.       if((nr>= 91)&&(nr<=120)) { tag=nr- 90; monat= 4; }
  133.       if((nr>=121)&&(nr<=151)) { tag=nr-120; monat= 5; }
  134.       if((nr>=152)&&(nr<=181)) { tag=nr-151; monat= 6; }
  135.       if((nr>=182)&&(nr<=212)) { tag=nr-181; monat= 7; }
  136.       if((nr>=213)&&(nr<=243)) { tag=nr-212; monat= 8; }
  137.       if((nr>=244)&&(nr<=273)) { tag=nr-243; monat= 9; }
  138.       if((nr>=274)&&(nr<=304)) { tag=nr-273; monat=10; }
  139.       if((nr>=305)&&(nr<=334)) { tag=nr-304; monat=11; }
  140.       if((nr>=335)&&(nr<=365)) { tag=nr-334; monat=12; }
  141.     } /* if(schalttag==0) */ else
  142.       if(schalttag==1) {
  143.         if((nr>=  1)&&(nr<= 31)) { tag=nr;     monat= 1; }
  144.         if((nr>= 32)&&(nr<= 60)) { tag=nr- 31; monat= 2; }
  145.         if((nr>= 61)&&(nr<= 91)) { tag=nr- 60; monat= 3; }
  146.         if((nr>= 92)&&(nr<=121)) { tag=nr- 91; monat= 4; }
  147.         if((nr>=122)&&(nr<=152)) { tag=nr-121; monat= 5; }
  148.         if((nr>=153)&&(nr<=182)) { tag=nr-152; monat= 6; }
  149.         if((nr>=183)&&(nr<=213)) { tag=nr-182; monat= 7; }
  150.         if((nr>=214)&&(nr<=244)) { tag=nr-213; monat= 8; }
  151.         if((nr>=245)&&(nr<=274)) { tag=nr-244; monat= 9; }
  152.         if((nr>=275)&&(nr<=305)) { tag=nr-274; monat=10; }
  153.         if((nr>=306)&&(nr<=335)) { tag=nr-305; monat=11; }
  154.         if((nr>=336)&&(nr<=366)) { tag=nr-335; monat=12; }
  155.       } /* if(schalttag==1) */
  156.  
  157.     tempdatum.t=tag;
  158.     tempdatum.m=monat;
  159.     return tempdatum;
  160. } /* nummer_in_datum() */
  161.  
  162.  
  163. /*******************************************************************************
  164. *   Verwandelt ein Datum im julian. Kalender in ein Datum im greg. Kalender.
  165. *   Nach: J. Bach, Die Zeit- und Festrechnung der Juden unter besonderer
  166. *   Beruecksichtigung der gaussschen Osterformel nebst einem immerwährenden
  167. *   Kalender, Freiburg i. B. 1908, 26.
  168. *   Vgl. auch Chr. Zeller, Kalender-Formeln, Acta Mathematica 9 (1887), 135.
  169. ********************************************************************************/
  170. datum konv_in_greg(datum julian_datum)
  171. {
  172.     datum   dat=julian_datum;
  173.     ganz    h=floor(dat.j/100),
  174.  
  175.         /* 1, weil Datum des julian. Kal. uebergeben */
  176.         nr=datum_in_nummer(1,dat),
  177.  
  178.         neue_nr=nr+(h-floor(h/4)-2);
  179.  
  180.     /* S.o., Kommentar zur Variablen "nr": */
  181.     return nummer_in_datum(1,neue_nr,dat.j);
  182. } /* konv_in_greg() */
  183.  
  184.  
  185. /****************************************************************************
  186. *   WochenTagsNummeR bestimmen nach:
  187. *   Chr. Zeller, Kalender-Formeln, Acta Mathematica, Band 9 (1887), 131f.
  188. *   So.=1, Mo.=2, Di.=3, Mi.=4, Do.=5, Fr.=6, Sa.=0
  189. *****************************************************************************/
  190. ganz wtnr(ganz stil,datum tagesdatum)
  191. {
  192.     datum   dat=tagesdatum;
  193.         /* h NICHT "ganz"! h kann negativ werden, s.u. */
  194.     int h,j=floor(dat.j/100),k=dat.j-j*100,ks=stil,m=dat.m,q=dat.t;
  195.  
  196.     if(m==1) { /* Januar 13. Monat des VORjahres */
  197.       m=13;
  198.       k--;
  199.     } /* if(m==1) */
  200.  
  201.     if(m==2) { /* Februar 14. Monat des VORjahres */
  202.       m=14;
  203.       k--;
  204.     } /* if(m==2) */
  205.  
  206.     if(ks==1) h=(q+floor(26*(m+1)/10)+k+floor(k/4)+5-j); else
  207.       if(ks==2) h=(q+floor(26*(m+1)/10)+k+floor(k/4)+floor(j/4)-2*j);
  208.  
  209.     /* if(h<0)… ist unnoetig */
  210.     while(h<0) /* S.o., Kommentar zur Vereinbarung von h */
  211.       h+=7;
  212.  
  213.     return h%7;
  214. } /* wtnr() */
  215.  
  216.  
  217. /***************************************************
  218. *   Wochentag nach Nummer bestimmen und ausgeben
  219. *   Nummern nach: ganz wtnr(ganz,datum)
  220. ****************************************************/
  221. void wochentag_ausgeben(ganz nummer)
  222. {
  223.     ganz n=nummer;
  224.  
  225.     switch(n) {
  226.       case 0: printf ("Sa"); break;
  227.       case 1: printf ("So"); break;
  228.       case 2: printf ("Mo"); break;
  229.       case 3: printf ("Di"); break;
  230.       case 4: printf ("Mi"); break;
  231.       case 5: printf ("Do"); break;
  232.       case 6: printf ("Fr"); break;
  233.     } /* switch(n) */
  234.     printf(".");
  235. } /* wochentag_ausgeben() */
  236.  
  237.  
  238. /******************************************************************
  239. *   Ostersonntag bestimmen nach: Chr. Zeller, Kalender-Formeln,
  240. *   Acta Mathematica, Band 9 (1887), 133-136.
  241. *******************************************************************/
  242. datum ostersonntag(ganz stil,ganz jahr)
  243. {
  244.     ganz    a,b,d,n=jahr,monat=4,tag,ks=stil;
  245.     datum   ostern;
  246.  
  247.     if(ks==1) { /* julian. Kalender */
  248.       a=n%19;
  249.       b=(ganz)(19*n-floor(n/19)+15)%30;
  250.       d=(ganz)(b+n+floor(n/4))%7;  
  251.     } /* if(ks==1) */
  252.  
  253.     if(ks==2) { /* gregorian. Kalender */
  254.       a=n%19;
  255.       b=(ganz)(19*n-floor(n/19)+15+(floor(n/100)-floor(n/300)-floor(n/400)))%30;
  256.       d=(ganz)(b+n+floor(n/4)-(floor(n/100)-floor(n/400)-2))%7;
  257.     } /* if(ks==2) */
  258.  
  259.     if((d==0)&&(b==29)) d=7; else
  260.       if((d==0)&&(b==28)&&(a>10)) d=7;
  261.  
  262.     tag=21+b+7-d;
  263.     if(tag>31) tag-=31; else monat=3;
  264.  
  265.     ostern.t=tag;
  266.     ostern.m=monat;
  267.     ostern.j=n;
  268.     return ostern;
  269. } /* ostersonntag() */
  270.  
  271.  
  272. /******************************************
  273. *   Datum des 1. Advents bestimmen
  274. *   Nummern nach: ganz wtnr(ganz,datum)
  275. *******************************************/
  276. datum erster_advent(ganz stil,ganz jahr)
  277. {
  278.     ganz    basis,j=jahr,ks=stil,tag;
  279.     datum   dat;
  280.  
  281.     /*
  282.       kfta() legt den Stil nach der Jahreszahl beim
  283.       Funktionsaufruf automatisch fest, 1582 gilt z.T.
  284.       noch der julianische Kalender, der Advent 1582
  285.       liegt aber schon nach der Reform, deshalb
  286.       wird hier gesondert festgelegt, dass Ende
  287.       1582 der gregorianische Kalender anzuwenden ist:
  288.     */
  289.     if(j==1582) ks=2;
  290.  
  291.     /* 27. Nov.: 331. Tag im Jahr+ggf. Schalttag: */
  292.     basis=331+schaltjahr(ks,j);
  293.  
  294.     dat=nummer_in_datum(ks,basis,j);
  295.  
  296.     switch(wtnr(ks,dat)) {
  297.       case 0: tag=basis+1; break;
  298.       case 1: tag=basis  ; break;
  299.       case 2: tag=basis+6; break;
  300.       case 3: tag=basis+5; break;
  301.       case 4: tag=basis+4; break;
  302.       case 5: tag=basis+3; break;
  303.       case 6: tag=basis+2; break;
  304.     } /* switch(wtnr(ks,dat)) */
  305.  
  306.     return (nummer_in_datum(ks,tag,j));
  307. } /* erster_advent() */
  308.  
  309.  
  310. /**************************************************************************
  311. *   Datum des Weihnachtsfestes im julian. Kalender in entsprechendes
  312. *   Datum des gregorian. Kalender verwandeln, analog zu "konv_in_greg";
  313. *   eine separate Funktion ist noetig, weil der Kalenderstil fuer die
  314. *   Schaltjahresberechnung hier jahresunabhaengig julianisch sein muss.
  315. *   Wieder nach: Bach, Festrechnung, 26,
  316. *   s.o.: datum konv_in_greg (datum julian_datum).
  317. ***************************************************************************/
  318. datum konv_orth_weihnachten(datum julian_datum)
  319. {
  320.     datum dat=julian_datum;
  321.     ganz h=floor(dat.j/100),
  322.     /* 1, weil Datum des jul. Kal. uebergeben, auch unten: */
  323.     nr=datum_in_nummer(1,dat),neue_nr=nr+(h-floor(h/4)-2);
  324.  
  325.     if(neue_nr>365+schaltjahr(1,dat.j)) { /*  immer jul. Kalender */
  326.       neue_nr-=(365+schaltjahr(1,dat.j));
  327.       dat.j++; /* Jahresgrenze ueberschritten */
  328.     } /* if(neue_nr>365+schaltjahr(1,dat.j) */
  329.  
  330.     return nummer_in_datum(1,neue_nr,dat.j);
  331. } /* konv_orth_weihnachten() */
  332.  
  333.  
  334. /*******************************************
  335. *   kfta="Kirchliche FeierTage Ausgeben"
  336. *   Die Ausgabe erfolgt als CSV, ein
  337. *   Semikolon dient jeweils als Trenner.
  338. ********************************************/
  339. void kfta(ganz untergr,ganz obergr)
  340. {
  341.     ganz    jahr,ks,o=obergr,u=untergr;
  342.     datum   dat,neu;
  343.  
  344.     for(jahr=u;jahr<=o;jahr++) {
  345.       if(jahr<1583) ks=1; else  /* 1: julianischer Stil */
  346.         ks=2;           /* 2: gregorianischer Stil */
  347.       /*
  348.         Die obige automatische Festlegung des Stils wird z. T.
  349.         ausser Kraft gesetzt, z.B. teilweise im Jahr 1582 oder
  350.         wenn Formeln einen bestimmten Stil erfordern.
  351.       */
  352.       dat=ostersonntag(ks,jahr);    /* Westkirche */
  353.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)-46,jahr);
  354.       printf("Aschermittw.: %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  355.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)- 2,jahr);
  356.       printf("Karfreitag   : %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  357.       printf("Ostern: %2u.%2u.%4u;   ",dat.t,dat.m,dat.j);
  358.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)+39,jahr);
  359.       printf("Chr. Himmelf.: %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  360.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)+49,jahr);
  361.       printf("Pfingstso.: %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  362.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)+60,jahr);
  363.       printf("Fronleichnam: %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  364.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)+68,jahr);
  365.       printf("Herz-Jesu-Fr.: %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  366.  
  367.       printf("Mariae Himmelf.: "); /* Wochentag ausgeben */
  368.       neu.t=15; /* Immer am 15. August */
  369.       neu.m=8;
  370.       neu.j=jahr;
  371.       wochentag_ausgeben(wtnr(ks,neu));
  372.  
  373.       dat=erster_advent(ks,jahr); /* 1. Advent als Basis fuer… */
  374.       neu=nummer_in_datum(ks,datum_in_nummer(ks,dat)-11,jahr); /* …Buss-/Bettag: */
  375.       printf("; Buss/Bettag: %2u.%2u.%4u; ",neu.t,neu.m,neu.j);
  376.       printf("1. Advent: %2u.%2u.%4u; ",dat.t,dat.m,dat.j); /* …1. Advent */
  377.  
  378.       if(jahr>=1582) {  /* Orthodoxie behaelt julian. Kalender bei*/  
  379.         if(jahr>1582) { /* Ostern 1582 noch vor gregorian. Reform */
  380.           printf("Orthodoxes Osterfest  : ");
  381.           dat=ostersonntag(1,jahr); /* 1 fuer Formel des jul. Kalenders */
  382.           printf("%2u.%2u.%4u [JULIANISCH] ",dat.t,dat.m,dat.j);
  383.           neu=konv_in_greg(dat);
  384.           printf("= %2u.%2u.%4u im ",neu.t,neu.m,neu.j);
  385.           printf("westlichen GREGORIANISCHEN Kalender; ");
  386.         } /* if(jahr>1582) */
  387.         /* Weihnachten 1582 schon nach Kalenderreform: */
  388.         printf("Orthodoxes Weihnachten: 25.12.%4u [JULIANISCH] ",jahr);
  389.         dat.t= 25;
  390.             dat.m= 12;
  391.             dat.j=jahr;
  392.         neu=konv_orth_weihnachten(dat);
  393.         printf("= %2u.%2u.%4u im ",neu.t,neu.m,neu.j);
  394.             printf("westlichen GREGORIANISCHEN Kalender\n");      
  395.       } /* if(jahr>=1582) */
  396.     } /* for(jahr=u;jahr<=o;jahr++) */
  397. } /* kfta() */
  398.  
  399.  
  400. /****************************************************************
  401. *   Gewinnt aus den Sekunden seit 1.1.1970 das laufende Jahr.
  402. *   !   BUG: Am 01. Januar bis 01:00 Uhr morgens wird   !
  403. *   !   anscheinend noch das Vorjahr zurueckgeliefert.  !
  404. *****************************************************************/
  405. int jahr_aus_systemdatum(void)
  406. {
  407.  
  408.     long    /* t speichert Sekunden seit 1.1.1970, 00:00h: */
  409.         t=time(NULL),
  410.         /* Anfangsjahr der UNIX-Zeit: */
  411.         jahr=1970;
  412.  
  413.     do {
  414.       /* Sekunden eines Jahres abziehen (60*60*24*365): */
  415.       t-=31536000;
  416.  
  417.       /*
  418.         Schaltjahr? Dann ggf. auch die Sekunden des
  419.         Schalttages abziehen, 1970 und danach wird immer
  420.         die Schaltregel des gregorianischen Kalenders
  421.         beachtet, deshalb hat Stil hier immer den Wert 2:
  422.       */
  423.       if(schaltjahr(2,jahr)==1) t-=86400;
  424.  
  425.       jahr++; /* zum naechsten Jahr springen */
  426.     } while(t>0);
  427.  
  428.  
  429.     /* Kurz und weniger uebersichtlich: */
  430.     /* 
  431.       while(t>0)
  432.         schaltjahr(2,jahr++)?(t-=31622400):(t-=31536000);
  433.     */
  434.  
  435.     return jahr-1;
  436. } /* jahr_aus_systemdatum() */
  437.  
  438.  
  439. /******************************************************************
  440. *   Fehlermeldung bei falschem Programmaufruf. Die Ausgaben
  441. *   sind zwar trivial, helfen aber, die optisch uebersichtliche
  442. *   Struktur des Hauptprogramms zu erhalten.
  443. *******************************************************************/
  444. int fmeldung(ganz nummer)
  445. {
  446.     ganz n=nummer;
  447.  
  448.     switch (n) {
  449.       case 1: printf("Usage: kft [year] [year]\n"); break;
  450.       case 2: printf("0<Year<=%u\n",GRENZE);    break;
  451.     } /* switch(n) */
  452.  
  453.     return 0;
  454. } /* fmeldung() */
  455.  
  456.  
  457. /**********************************************************************
  458. *   Es muss dem Benutzer ueberlassen bleiben, theologisch sinnvolle
  459. *   Jahreszahlen auszuwaehlen: Eine Berechnung des Osterdatums fuer
  460. *   das Jahr 1 n.Chr. waere rechnerisch zwar moeglich, aber
  461. *   theologisch nicht sinnvoll, ebensowenig ergaebe die Berechnung
  462. *   des Fronleichnamsdatums fuer das Fruehmittelalter Sinn.
  463. ***********************************************************************/
  464. int main(int argc,char *argv[])
  465. {
  466.     /*
  467.     og: Obergrenze (Jahreszahl) fuer Feiertagsberechnung.
  468.     ug: Untergrenze     "-"
  469.     t : Jahreszahlen tauschen, wenn Untergrenze>Obergrenze ist.
  470.     */
  471.     ganz og,ug,t;
  472.  
  473.     /* Jahr aus dem Systemdatum gewinnen: */
  474.     ug=jahr_aus_systemdatum(); /* Bug beachten! */
  475.     /*
  476.         Falls mindestens ein Parameter angegeben wurde,
  477.         diesen fuer ug verwenden:
  478.     */
  479.     if(argc>1) ug=atoi(argv[1]);
  480.  
  481.     if(ug>GRENZE) fmeldung(2); else
  482.       if(argc>3) fmeldung(1); else
  483.         if(argc==1) kfta(ug,ug); /* Systemdatum verwenden */ else
  484.           if(ug==0) fmeldung(2); else
  485.             if(argc==2) /* Feiertage eines Jahres berechnen */
  486.               if(ug>GRENZE) fmeldung(2); else kfta(ug,ug); else
  487.                 if(argc==3) { /* … von Jahr1 bis Jahr2 ausgeben */
  488.                   og=atoi(argv[2]);
  489.                   if(og==0) fmeldung(2); else
  490.                     if(og!=0) {
  491.                       /* ug groesser als og? Werte tauschen: */
  492.                       ug>og?t=ug,ug=og,og=t:0;
  493.                       if(og>GRENZE) fmeldung(2); else kfta(ug,og);
  494.                     } /* if(og!=0) */ else fmeldung(1);
  495.                 } /* if(argc==3) */
  496.  
  497.     return 0;
  498. } /* main() */
  499.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!