XProfan

/* Datum/Zeit-Funktionen (ab vX2) 

dt("Compare",D1,D2)               -- vergleicht zwei Zeitpunkte (signum)
dt("CompareDate",D1,D2)           -- vergleicht zwei Datumswerte (signum)
dt("CompareTime",D1,D2)           -- vergleicht zwei Uhrzeiten (signum)

dt("DateTimeStr",S[,D])           -- foramtierte Ausgabe von Datum und Zeit
dt("DaysBetween",D1,D2)           -- Tage zwischen zwei Datumswerten

dt("getDate",N[,D])               -- ermittelt das Datum in verschiedenen Schreibweisen
dt("getDay",D)                    -- ermittelt den Tag eines Zeitpunktes
dt("getMonth",D)                  -- ermittelt den Monat eines Zeitpunktes
dt("getYear",D)                   -- ermittelt das Jahr eines Zeitpunktes
dt("getTime",N[,D])               -- ermittelt die Uhrzeit in verschiedenen Schreibweisen
dt("getHour",D)                   -- ermittelt die Stunde eines Zeitpunktes
dt("getMin",D)                    -- ermittelt die Minute eines Zeitpunktes
dt("getSec",D)                    -- ermittelt die Sekunde eines Zeitpunktes
dt("getMilliSec",D)               -- ermittelt die MilliSekunde eines Zeitpunktes

dt("getDoW",D)                    -- ermittelt den Wochentag eines Zeitpunktes (1..7, 1=Mo)
dt("getDoY",D)                    -- ermittelt den Tag im Jahr eines Zeitpunktes (1..366)
dt("getWoY",D)                    -- ermittelt die Jahreswoche eines Zeitpunktes (1..53)

dt("incDay",D,N)                  -- erhöht den Tag
dt("incMonth",D,N)                -- erhöht die Monate
dt("incYear",D,N)                 -- erhöht das Jahr
dt("incHour",D,N)                 -- erhöht die Stunden
dt("incMin",D,N)                  -- erhöht die Minuten
dt("incSec",D,N)                  -- erhöht die Sekunden

dt("IsLeapYear",D)                -- prüft auf Schaltjahr

dt("setDateTime",y,m,d,h,n,s,ms)  -- setzt den Zeitpunkt
dt("setDate",S[,D])               -- setzt das Datum
dt("setDate",y,m,d[,D])           -- setzt das Datum
dt("setDay",D,N)                  -- setzt den Tag
dt("setMonth",D,N)                -- setzt den Monat
dt("setYear",D,N)                 -- setzt das Jahr
dt("setTime",h,n,s,ms[,D])        -- setzt die Uhrzeit
dt("setTime",S[,D])               -- setzt die Uhrzeit
dt("setHour",D,N)                 -- setzt die Stunde
dt("setMin",D,N)                  -- setzt die Minute
dt("setSec",D,N)                  -- setzt die Sekunde
dt("setMilliSec",D,N)             -- setzt die Millisekunde
*/


/* Neu hinzugefügt:

dt("Advent4",Jahr%)       -- ermittelt Datum des 4. Advent als Zeitpunkt
dt("Ostern",Jahr%)        -- ermittelt Datum des Ostersonntages als Zeitpunkt
dt("LastDayInMonth",M,Y)  -- ermittelt Ultimo-Tag des Monats
dt("BoM",D)               -- ermittelt den Beginn des Monats (Beginning of Month)
dt("EoM",D)               -- ermittelt das Ende des Monats (End of Month)
dt("Quarter",D)           -- ermittelt die QuartalsNr des Datums (1..4)
dt("BoQ",D)               -- ermittelt den ersten  Tag des Quartals des Datums ( 1.1. /  1.4. /  1.7. /  1.10.) (Beginning of Quarter)
dt("EoQ",D)               -- ermittelt den letzten Tag des Quartals des Datums (31.3. / 30.4. / 30.9. / 31.12.) (End of Quarter)
dt("setBoQ",y,q)          -- ermittelt aus Jahr u. QuartalsNr. das Datum (Beginning of Quarter)
dt("setEoQ",y,q)          -- ermittelt aus Jahr u. QuartalsNr. das Datum (End of Quarter)
dt("BoW",D)               -- ermittelt den Wochenbeginn (Montag)  (Beginning of Week)
dt("EoW",D)               -- ermittelt das Wochenende   (Sonntag) (End       of Week)
dt("BoY",D)               -- ermittelt den Jahresbeginn ( 1. 1.) (Beginning of Year)
dt("EoY",D)               -- ermittelt das Jahresende   (31.12.) (End of Year)

dt("WeekdayStep",D,"Mod") -- ermittelt auf Wochentag korrigiertes Datum
*/
/*
WeekdayStep:
   Der erste Teil des Modus-Strings enthält:                    First,Prev,Next,Last
   Der zweite Teil ist der gewünschte Wochentag als Abkürzung:  Mo,Di,Mi,Do,Fr,Sa,So, Mo,Tu,We,Th,Fr,Sa,Su
*/


/*
Ermittlung des 4. Advent.
Hieraus ergeben sich dann die folgenden Daten:
-- dt("Advent4",Jahr%)		= 4. Advent
-- dt("Advent4",Jahr%) - 7	= 3. Advent
-- dt("Advent4",Jahr%) - 14	= 2. Advent
-- dt("Advent4",Jahr%) - 21	= 1. Advent
-- dt("Advent4",Jahr%) - 28	= Totensonntag
-- dt("Advent4",Jahr%) - 32	= Buß- und Bettag
-- dt("Advent4",Jahr%) - 35	= Volkstrauertag
*/
SubProc dt.Advent4
   Parameters Jahr%
   Declare Tag2512!
   Tag2512! = dt("SetDate", Jahr%,12,25)
   Return ( Tag2512! - dt("GetDoW",Tag2512!) )
EndProc


/*
Ermittlung des Ostersonntages.
Hieraus ergeben sich dann die folgenden Daten:
-- oSo = dt("Ostern",Jahr%)      	= OsterSo
-- (weitere siehe Kalender(): sind zu viele für hier)
*/
SubProc dt.Ostern
   Parameters int Y
   Declare int D,Mo, Century, r19, r30, x,x1,x2,x3,x4,x5
   Century = Int(Y / 100)  :  r19 = Y mod 19  :  x = ((Century - 15) >> 1) + 202 - r19 * 11
   Select Century
      CaseOf 21,24,25,27,28,29,30,31,32,34,35,38
         Dec x
      CaseOf 33,36,37,39,40
         Dec x, 2
   EndSelect
   r30 = x mod 30  :  x1 = r30 + 21
   Case r30 == 29 : Dec x1
   Case (r30 == 28) and (r19 > 10) : Dec x1
   x2 = (x1 - 19) mod 7  :  x3 = (40 - Century) mod 4
   Case x3 == 3 : Inc x3
   Case x3 > 1 : Inc x3
   x = Y mod 100  :  x4 = (x + x / 4) mod 7  :  x5 = ((20 - x2 - x3 - x4) mod 7) + 1
   D = x1 + x5  :  Mo = 3
   If D > 31
      Dec D,31
      Inc Mo
   EndIf
   Return dt("SetDate", Y,Mo,D)
EndProc


/* Beginning of Month */
SubProc dt.BoM
   Parameters D!
   Return dt("SetDay",D!,1)
EndProc


/* End of Month */
SubProc dt.EoM
   Parameters D!
   Declare D%,Mo%,Y%
   Y% = dt("getYear",D!)
   Mo% = dt("getMonth",D!)
   D% = dt("LastDayInMonth",Mo%,Y%)
   Return dt("SetDate", Y%,Mo%,D% )
EndProc


/* LastDayInMonth (Ultimo) */
SubProc dt.LastDayInMonth
   // Ultimo = dt("LastDayInMonth",M,Y)
   Parameters int M, Y
   Declare int Leap
   Var int LDiM[] = 0,  31, 28, 31, 30,  31,  30,   31,  31,  30,  31,  30,  31
   Var int Ultimo = -1
   Leap = if((((Y mod 4) = 0) and ((Y mod 100) <> 0)) or ((Y mod 400) = 0),1,0)  // isLeapYear(Y)
   Case Between(M,1,12) : Ultimo = LDiM[M] + if( (M = 2) and (Leap = 1), 1, 0)
   Return Ultimo
EndProc
SubProc dt.Ultimo
   Parameters int M, Y
   Return dt("LastDayInMonth",M,Y)
EndProc


/* Quarter */
SubProc dt.Quarter
   Parameters D!
   Return Int((dt("GetMonth",D!) - 1) / 3) + 1
EndProc
SubProc dt.Quartal
   Parameters D!
   Return dt("Quarter",D!)
EndProc


/* Beginning of Quarter */
SubProc dt.BoQ
   Parameters D!
   Declare M%
   M% = dt("GetMonth",D!) - 1
   D! = dt("SetDay",D!,1)
   Return dt("SetMonth",D!,(Int(M% / 3) + 1) * 3 - 2)
EndProc


/* End of Quarter */
SubProc dt.EoQ
   Parameters D!
   Declare M%
   M% = dt("GetMonth",D!) - 1
   D! = dt("SetDay",D!,1)
   Return dt("SetMonth",D!,(Int(M% / 3) + 1) * 3)
EndProc


/* Set Beginning of Quarter */
SubProc dt.setBoQ
   Parameters Year%, QuarterNo%
   Declare M%
   CaseNot Between(QuarterNo%,1,4) : QuarterNo% = 1
   M% = QuarterNo% * 3 - 2
   Return dt("SetDate",Year%,M%,1)
EndProc


/* Set End of Quarter */
SubProc dt.setEoQ
   Parameters Year%, QuarterNo%
   Declare M%
   CaseNot Between(QuarterNo%,1,4) : QuarterNo% = 1
   M% = QuarterNo% * 3
   Return dt("SetDate", Year%,M%, dt("LastDayInMonth",M%,Year%) )
EndProc


/* Beginning of Week */
SubProc dt.BoW
   Parameters D!
   Return ( D! - (dt("GetDoW",D!) - 1) )
EndProc


/* End of Week */
SubProc dt.EoW
   Parameters D!
   Return ( D! + (7 - dt("GetDoW",D!)) )
EndProc


/* Beginning of Year */
SubProc dt.BoY
   Parameters D!
   Return dt("SetDate",dt("GetYear",D!),1,1)
EndProc


/* End of Year */
SubProc dt.EoY
   Parameters D!
   Return dt("SetDate",dt("GetYear",D!),12,31)
EndProc


/* WeekdayStep: Wochentage durchlaufen */
/*    - FirstMo  - PrevDi  - NextDo  - LastSa */
SubProc dt.WeekdayStep
   Parameters D!, Modus$
   Declare Mode%, WDay$, WD%, W%
   Modus$ = Lower$(Modus$)  :  WDay$ = Right$(Modus$,2)  :  WD% = 0
   Case InStr("first",Modus$) : Mode% = 0
   Case InStr("prev",Modus$) : Mode% = 1
   Case InStr("next",Modus$) : Mode% = 2
   Case InStr("last",Modus$) : Mode% = 3
   WhileLoop 1,14
      If SubStr$("mo,di,mi,do,fr,sa,so,mo,tu,we,th,fr,sa,su", &Loop, ",") = WDay$
         Case &Loop <= 7 : WD% = &Loop - 1
         Case &Loop  > 7 : WD% = &Loop - 8
         BREAK
      EndIf
   EndWhile
   
   // Korrektur des Tages
   Case Mode% = 0 : D! = dt("BoM",D!)
   Case Mode% = 3 : D! = dt("EoM",D!)
  
   While WD% < 0 : Inc WD%,7 : EndWhile : WD% = WD% mod 7 : Inc WD%
   W% = dt("getDoW",D!)
   Select Mode%
     CaseOf 0  // First
       While W% <> WD%
         D! = D! + 1
         Inc W%
         Case W% > 7 : W% = 1
       EndWhile
     CaseOf 1  // Prev
       Repeat
         D! = D! - 1
         Dec W%
         Case W% < 1 : W% = 7
       Until W% = WD%
     CaseOf 2  // Next
       Repeat
         D! = D! + 1
         Inc W%
         Case W% > 7 : W% = 1
       Until W% = WD%
     CaseOf 3  // Last
       While W% <> WD%
         D! = D! - 1
         Dec W%
         Case W% < 1 : W% = 7
       EndWhile
   EndSelect
   Return D!
EndProc

/* nur zur Vereinfachung mit aufgenommen */
SubProc dt.FirstMo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstMo")  :  EndProc
SubProc dt.FirstDi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstDi")  :  EndProc
SubProc dt.FirstMi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstMi")  :  EndProc
SubProc dt.FirstDo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstDo")  :  EndProc
SubProc dt.FirstFr  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstFr")  :  EndProc
SubProc dt.FirstSa  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstSa")  :  EndProc
SubProc dt.FirstSo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstSo")  :  EndProc
SubProc dt.FirstTu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstTu")  :  EndProc
SubProc dt.FirstWe  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstWe")  :  EndProc
SubProc dt.FirstTh  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstTh")  :  EndProc
SubProc dt.FirstSu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"FirstSu")  :  EndProc

SubProc dt.PrevMo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevMo")  :  EndProc
SubProc dt.PrevDi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevDi")  :  EndProc
SubProc dt.PrevMi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevMi")  :  EndProc
SubProc dt.PrevDo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevDo")  :  EndProc
SubProc dt.PrevFr  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevFr")  :  EndProc
SubProc dt.PrevSa  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevSa")  :  EndProc
SubProc dt.PrevSo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevSo")  :  EndProc
SubProc dt.PrevTu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevTu")  :  EndProc
SubProc dt.PrevWe  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevWe")  :  EndProc
SubProc dt.PrevTh  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevTh")  :  EndProc
SubProc dt.PrevSu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"PrevSu")  :  EndProc

SubProc dt.NextMo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextMo")  :  EndProc
SubProc dt.NextDi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextDi")  :  EndProc
SubProc dt.NextMi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextMi")  :  EndProc
SubProc dt.NextDo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextDo")  :  EndProc
SubProc dt.NextFr  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextFr")  :  EndProc
SubProc dt.NextSa  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextSa")  :  EndProc
SubProc dt.NextSo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextSo")  :  EndProc
SubProc dt.NextTu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextTu")  :  EndProc
SubProc dt.NextWe  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextWe")  :  EndProc
SubProc dt.NextTh  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextTh")  :  EndProc
SubProc dt.NextSu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"NextSu")  :  EndProc

SubProc dt.LastMo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastMo")  :  EndProc
SubProc dt.LastDi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastDi")  :  EndProc
SubProc dt.LastMi  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastMi")  :  EndProc
SubProc dt.LastDo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastDo")  :  EndProc
SubProc dt.LastFr  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastFr")  :  EndProc
SubProc dt.LastSa  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastSa")  :  EndProc
SubProc dt.LastSo  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastSo")  :  EndProc
SubProc dt.LastTu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastTu")  :  EndProc
SubProc dt.LastWe  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastWe")  :  EndProc
SubProc dt.LastTh  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastTh")  :  EndProc
SubProc dt.LastSu  :  Parameters D!  :  Return dt("WeekdayStep",D!,"LastSu")  :  EndProc


/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Proc Kalender
   Parameters int Y
   Declare int DoY, float dd, LastDat, xmas, adv4, ea, septua, trini_stop, string Kalenderdatei, xx
   adv4 = dt("Advent4",Y) : trini_stop = adv4 - 35  // Ende der Trinitatis-Sonntage (Woche vor Volkstrauertag)
   ea   = dt("Ostern",Y)  : septua     = ea   - 63  // Ende der Epiphanias-Sonntage (Woche vor Septuagesimä)
   
   Proc Fix
      Parameters int d,m,y, string s
      declare int DoY
      LastDat = dt("setDate",y,m,d) : doy = dt("getDoY",LastDat) + 1000
      AddString(0,str$(doy) $ " | " $ dt("DateTimeStr","dd.mm.yyyy (ddd) | ",LastDat) $ s)
   EndProc
   Proc Vari
      Parameters float da, string s
      declare int DoY
      LastDat = da : doy = dt("getDoY",LastDat) + 1000
      AddString(0,str$(doy) $ " | " $ dt("DateTimeStr","dd.mm.yyyy (ddd) | ",LastDat) $ s)
   EndProc
   
   ClearList 0
   fix( 1, 1,Y,"Neujahr [F]")
      dd = dt("NextSo",LastDat) : Case dt("getDoY",dd) < 6 : vari(dd,"So. n. Neujahr")
   fix( 6, 1,Y,"Hl. 3 Könige (Epiphanias) [f;BW,BY,ST]")
      dd = dt("NextSo",LastDat)
      WhileLoop 1,6 : Case dd < septua : vari(dd, &Loop $ ". So. n. Epiphanias") : dd = dt("NextSo",dd) : EndWhile
   fix( 2, 2,Y,"Mariä Lichtmeß")
   fix(14, 2,Y,"Valentinstag")
   fix(25, 3,Y,"Mariä Verkündigung")
   fix(30, 4,Y,"Walpurgisnacht")
   fix(24, 6,Y,"Johannistag")
   fix(27, 6,Y,"Siebenschläfer")
   fix(29, 6,Y,"Peter und Paul")
   fix(15, 8,Y,"Mariä Himmelfahrt [f;BY,SL]")
   fix(24, 8,Y,"Bartholomäustag")
   fix( 1, 9,Y,"Ägidii")
   fix( 8, 9,Y,"Mariä Geburt")
   fix(29, 9,Y,"Michaelis")
' Im Jahr 2017, dem 500. Jahr des Beginns der Reformation, 
' ist der 31. Oktober einmalig ein gesamtdeutscher
' gesetzlicher Feiertag.
if (Y = 2017) 
   fix(31,10,Y,"Reformationstag [F]")
Else
   fix(31,10,Y,"Reformationstag [f;BB,MV,SN,ST,TH]")
EndIf
   fix(31,10,Y,"Halloween")
   fix( 1,11,Y,"Allerheiligen [f;BW,BY,NW,RP,SL]")
   fix( 2,11,Y,"Allerseelen")
   fix(11,11,Y,"Martinstag (Martini)")
   fix( 6,12,Y,"Nikolaus")
   fix( 8,12,Y,"Mariä Empfängnis")
   fix(26,12,Y,"2. Weihnachtsfeiertag [F]")
   fix(31,12,Y,"Silvester")
   
   // Jahreszeiten
   fix(21, 3,Y,"Frühlings-Tagundnachtgleiche")
   fix(21, 6,Y,"Sommer-Sonnenwende")
   fix(22, 9,Y,"Herbst-Tagundnachtgleiche")
   fix(21,12,Y,"Winter-Sonnenwende")
   
   // Sternzeichen
   fix(21, 1,Y,"Sternzeichen Wassermann")
   fix(20, 2,Y,"Sternzeichen Fische")
   fix(21, 3,Y,"Sternzeichen Widder")
   fix(21, 4,Y,"Sternzeichen Stier")
   fix(21, 5,Y,"Sternzeichen Zwillinge")
   fix(22, 6,Y,"Sternzeichen Krebs")
   fix(23, 7,Y,"Sternzeichen Löwe")
   fix(24, 8,Y,"Sternzeichen Jungfrau")
   fix(24, 9,Y,"Sternzeichen Waage")
   fix(24,10,Y,"Sternzeichen Skorpion")
   fix(23,11,Y,"Sternzeichen Schütze")
   fix(22,12,Y,"Sternzeichen Steinbock")
   
   Case Y >= 1934 : fix( 1, 5,Y,"Maifeiertag [F]")
   Case Y >= 1964 : fix( 5, 5,Y,"Europatag (Gründung des Europarates 1949)")
   Case Y >= 1985 : fix( 9, 5,Y,"Europatag (Schuman-Erklärung (1950), mündete in EGKS u später EU)")
   If Between(Y,1954,1990)
      fix(17, 6,Y,"Tag der deutschen Einheit [F]")
   ElseIf Y >= 1991
      fix(17, 6,Y,"Tag der deutschen Einheit [Gedenktag]")
   EndIf
   Case Y >= 1990 : fix( 3,10,Y,"Tag der Deutschen Einheit [F]")

   // Sommerzeit
   vari( dt("LastSo",dt("setDate",Y, 3,1)), "Anfang der Sommerzeit (MESZ)")  // letzter SO im März
   vari( dt("LastSo",dt("setDate",Y,10,1)), "Ende der Sommerzeit (Normalzeit) (MEZ)")  // letzter SO im Oktober
   
   // Muttertag
   Case Y >= 1933 : vari( dt("FirstSo",dt("setDate",Y,5,1)) + 7, "Muttertag")  // zweiter SO im Mai (Trick: erster SO + 7)

   // Erntedank rk & ev
   Case Y >= 1972 : vari( dt("FirstSo",dt("setDate",Y,9,1)), "Erntedankfest (1. SO i Sept) [rk]")
   Case Y >= 1770 : vari( dt("NextSo",dt("setDate",Y,9,29)), "Erntedankfest (SO n Michaelis) [ev]")

   // Trinitatis-Sonntage (1..27)
   If Y >= 1334
      dd = ea + 56 + 7
      WhileLoop 1,27
         Case dd < trini_stop : vari(dd, &Loop $ ". So. n. Trinitatis")
         dd = dd + 7
      EndWhile
   EndIf


   // Advent
'  adv4 = dt("Advent4",Y)
   fix(25,12,Y,"1. Weihnachtsfeiertag [F]")
      xmas = LastDat
      If (LastDat - 1) = adv4
         fix(24,12,Y,"4. Advent und Heiligabend")
      Else
         fix(24,12,Y,"Heiligabend")
         vari(adv4,"4. Advent")
      EndIf
      Case dt("getDoW",xmas) <= 5 : vari(dt("NextSo",xmas),"So. n. Weihnachten")
   vari(adv4 - 7 ,"3. Advent")
   vari(adv4 - 14,"2. Advent")
   vari(adv4 - 21,"1. Advent")
   vari(adv4 - 28,"Totensonntag (Ewigkeitssonntag) [G]")
   vari(adv4 - 28,"Christkönigsfest [rk]")
   If Between(Y,1934,1938)
      vari(adv4 - 32,"Buß- und Bettag [F]")
   ElseIf Between(Y,1946,1951)
      vari(adv4 - 32,"Buß- und Bettag [f;BE,BW,HB,HE,HH,NI,NW,RP,SH,SL]")
   ElseIf Between(Y,1952,1980)
      vari(adv4 - 32,"Buß- und Bettag [f;BE,BW,BY(ev),HB,HE,HH,NI,NW,RP,SH,SL]")
   ElseIf Between(Y,1981,1989)
      vari(adv4 - 32,"Buß- und Bettag [f;BE,BW,BY,HB,HE,HH,NI,NW,RP,SH,SL]")
   ElseIf Between(Y,1990,1994)
      vari(adv4 - 32,"Buß- und Bettag [F;BE,BW,BY,HB,HE,HH,NI,NW,RP,SH,SL,BB,MV,SN,ST,TH]")
   ElseIf Y >= 1995
      vari(adv4 - 32,"Buß- und Bettag [f;SN]")
   EndIf
   vari(adv4 - 35,"Volkstrauertag")
   vari(adv4 - 42,"Drittletzter SO des Kirchenjahres")


   // Ostern
'  ea = dt("Ostern",Y)
   vari(ea - 52,"Weiberfastnacht (Schmotziger DO) (-Karneval-)")
   vari(ea - 51,"Rußiger Freitag (-Karneval-)")
   vari(ea - 50,"Nelkensamstag (Schmalziger SA) (-Karneval-)")
   vari(ea - 49,"Tulpensonntag (Herrenfastnacht) (-Karneval-)")
   vari(ea - 48,"Rosenmontag (-Karneval-)")
   vari(ea - 47,"Fastnacht (Veilchendienstag) (-Karneval-)")
   vari(ea - 46,"Aschermittwoch (Beginn der Fastenzeit) (-Karneval-)")
   
   vari(ea - 63,"Septuagesimae (9.So v Ostern)")
   vari(ea - 56,"Sexagesimae (8.So v Ostern)")
   vari(ea - 49,"Estomihi (7.So v Ostern)")
   vari(ea - 42,"Invokavit (6.FastenSo v Ostern)")
   vari(ea - 35,"Reminiscere (5.FastenSo v Ostern)")
   vari(ea - 28,"Okuli (4.FastenSo v Ostern)")
   vari(ea - 21,"Laetare (3.FastenSo v Ostern)")
   vari(ea - 14,"Judica (2.FastenSo v Ostern)")
   vari(ea -  8,"[en] (Sat. of Lazarus)")
   vari(ea -  7,"Palmsonntag (1.FastenSo v Ostern)")
   vari(ea -  3,"Gründonnerstag")
   vari(ea -  2,"Karfreitag [F]")
   vari(ea -  1,"Karsamstag (Ostersamstag)")
   vari(ea     ,"Ostersonntag (rk:1.So der Osterzeit) [f;BB]")
   vari(ea +  1,"Ostermontag [F]")
   vari(ea +  7,"Quasimodogeniti (ev:1.So n Ostern)(rk:2.So der Osterzeit/Weißer Sonntag)")
   vari(ea + 14,"Misericordias Domini (ev:2.So n Ostern)(rk:3.So der Osterzeit)")
   vari(ea + 21,"Jubilate (ev:3.So n Ostern)(rk:4.So der Osterzeit)")
   vari(ea + 28,"Kantate (ev:4.So n Ostern)(rk:5.So der Osterzeit)")
   vari(ea + 35,"Rogate (ev:5.So n Ostern)(rk:6.So der Osterzeit)")
   vari(ea + 39,"Christi Himmelfahrt (Vatertag/Herrentag) [F]")
   vari(ea + 42,"Exaudi (ev:6.So n Ostern)(rk:7.So der Osterzeit)")
   vari(ea + 49,"Pfingstsonntag (7.So n Ostern) [f;BB]")
   vari(ea + 50,"Pfingstmontag [F]")
   vari(ea + 53,"Fronleichnam (Corpus Domini, Corpus Christi) [f;BW,BY,HE,NW,RP,SL]")

   Case Y >= 1856 : vari(ea + 63,"Herz Jesu Fest (2. SO n Pfingsten)")
   Case Y >= 1334 : vari(ea + 56,"Trinitatis (8. So n Ostern; 1. SO n Pfingsten) Dreifaltigkeit/Dreieinigkeit")

   
   SortList 1
'   Kalenderdatei = $TempDir $ "\KALENDER_TEMP.txt"
   Declare int err
   MkDir "C:\TEMP"
   err = %IOResult
   Kalenderdatei = "C:\TEMP\KALENDER_" $ Y $ "_TEMP.txt"
   Move("ListToFile",Kalenderdatei)
'   WhileLoop 0,GetCount(0) - 1
'      xx = GetString$(0,&loop)
'      Print SubStr$(xx,2," | ") $ " " $ SubStr$(xx,3," | ")
'   EndWhile
'   Print "---" $ Kalenderdatei $ "---"
   ClearList
   Shell "NotePad " $ Kalenderdatei
EndProc

Proc Test
   Declare d1!,d2!,Y%, e%
   Proc Zeige
      Parameters d!,s$
      Print dt("DateTimeStr", "   ddd', der 'dd. mmmm yyyy; (", d! ) $ dt("getDoW",d!) $ "); " $ s$
   EndProc
   Proc Zeige2
      Parameters d1!,d2!,s$
      Print dt("DateTimeStr", "  dd.mm.yyyy (ddd)(", d1! ) $ dt("getDoW",d1!) $ "); " $ s$ $ dt("DateTimeStr", "  dd.mm.yyyy (ddd)(", d2! ) $ dt("getDoW",d2!) $ "); "
   EndProc
   Cls
   d2! = !now : Y% = dt("GetYear",d2!)
   Print "Advent4"
    d1! = dt("Advent4",Y%)
    Zeige(d1!, "4. Advent")
    Zeige(d1! - 7, "3. Advent")
    Zeige(d1! - 14, "2. Advent")
    Zeige(d1! - 21, "1. Advent")
    Zeige(d1! - 28, "Totensonntag")
    Zeige(d1! - 32, "Buß- und Bettag")
    Zeige(d1! - 35, "Volkstrauertag")
   Print "BoM/EoM - Beginning/End Of Month"
    Zeige2( dt("BoM",d1!), dt("EoM",d1!), "(BoM)")
   Print "BoQ - Beginning Of Quarter"
    Zeige2( dt("BoQ",d1!), dt("EoQ",d1!), "(BoQ)")
    whileloop 1,4
     Zeige2( dt("setBoQ",2016,&loop), dt("setEoQ",2016,&loop), "(setBoQ) " $ &loop $ ".Q.")
    endwhile
   Print "BoW - Beginning Of Week (Monday)"
    whileloop 1,4
     Zeige2( dt("BoW",dt("setBoQ",Y%,&loop) + 7), dt("EoW",dt("setEoQ",Y%,&loop) - 7), "(setBoQ) " $ &loop $ ".Q.")
    endwhile
   Print "BoY - Beginning Of Year"
    Zeige2( dt("BoY",d1!), dt("EoY",d1!), "(BoY)")
   Print "Ostern"
    d1! = dt("Ostern",Y%)
    Zeige(d1!, "Ostersonntag")
    Zeige(dt("bow",d1!), "Mo")
    Zeige(dt("eow",d1!), "So")
    
    d2! = dt("FirstSo",d1!)
    whileloop 1,4
     Zeige(d2!, &loop $ ". So")
     d2! = dt("NextSo",d2!)
    endwhile
'   WaitInput
   If dt("Quartal",!now) <= 2
     ' Vorjahr und aktuelles Jahr
     Kalender( dt("getYear",!now) - 1 )
     Kalender( dt("getYear",!now) )
   Else
     ' aktuelles Jahr und nächstes Jahr
     Kalender( dt("getYear",!now) )
     Kalender( dt("getYear",!now) + 1 )
   EndIf
   WaitInput
EndProc

Test
end

/* Datum/Zeit-Funktionen (ab XProfan X2) 
    Zeitpunkte werden als D angegeben.

dt("Compare",D1,D2)               -- vergleicht zwei Zeitpunkte  (Rückgabe signum)
dt("CompareDate",D1,D2)           -- vergleicht zwei Datumswerte  (Rückgabe signum)
dt("CompareTime",D1,D2)           -- vergleicht zwei Uhrzeiten  (Rückgabe signum)

dt("DateTimeStr",S[,D])           -- foramtierte Ausgabe von Datum und Zeit  (Rückgabe string)
dt("DaysBetween",D1,D2)           -- Tage zwischen zwei Datumswerten  (Rückgabe int)

dt("getDate",N[,D])               -- ermittelt das Datum in verschiedenen Schreibweisen  (Rückgabe string)
dt("getDay",D)                    -- ermittelt den Tag eines Zeitpunktes  (Rückgabe int)
dt("getMonth",D)                  -- ermittelt den Monat eines Zeitpunktes  (Rückgabe int)
dt("getYear",D)                   -- ermittelt das Jahr eines Zeitpunktes  (Rückgabe int)
dt("getTime",N[,D])               -- ermittelt die Uhrzeit in verschiedenen Schreibweisen  (Rückgabe string)
dt("getHour",D)                   -- ermittelt die Stunde eines Zeitpunktes  (Rückgabe int)
dt("getMin",D)                    -- ermittelt die Minute eines Zeitpunktes  (Rückgabe int)
dt("getSec",D)                    -- ermittelt die Sekunde eines Zeitpunktes  (Rückgabe int)
dt("getMilliSec",D)               -- ermittelt die MilliSekunde eines Zeitpunktes  (Rückgabe int)

dt("getDoW",D)                    -- ermittelt den Wochentag eines Zeitpunktes  (Rückgabe 1..7, 1=Mo)
dt("getDoY",D)                    -- ermittelt den Tag im Jahr eines Zeitpunktes  (Rückgabe 1..366)
dt("getWoY",D)                    -- ermittelt die Jahreswoche eines Zeitpunktes  (Rückgabe 1..53)

dt("incDay",D,N)                  -- erhöht den Tag  (Rückgabe float D)
dt("incMonth",D,N)                -- erhöht die Monate  (Rückgabe float D)
dt("incYear",D,N)                 -- erhöht das Jahr  (Rückgabe float D)
dt("incHour",D,N)                 -- erhöht die Stunden  (Rückgabe float D)
dt("incMin",D,N)                  -- erhöht die Minuten  (Rückgabe float D)
dt("incSec",D,N)                  -- erhöht die Sekunden  (Rückgabe float D)

dt("IsLeapYear",D)                -- prüft auf Schaltjahr  (Rückgabe 0..1)

dt("setDateTime",y,m,d,h,n,s,ms)  -- setzt den Zeitpunkt  (Rückgabe float D)
dt("setDate",S[,D])               -- setzt das Datum  (Rückgabe float D)
dt("setDate",y,m,d[,D])           -- setzt das Datum  (Rückgabe float D)
dt("setDay",D,N)                  -- setzt den Tag  (Rückgabe float D)
dt("setMonth",D,N)                -- setzt den Monat  (Rückgabe float D)
dt("setYear",D,N)                 -- setzt das Jahr  (Rückgabe float D)
dt("setTime",h,n,s,ms[,D])        -- setzt die Uhrzeit  (Rückgabe float D)
dt("setTime",S[,D])               -- setzt die Uhrzeit  (Rückgabe float D)
dt("setHour",D,N)                 -- setzt die Stunde  (Rückgabe float D)
dt("setMin",D,N)                  -- setzt die Minute  (Rückgabe float D)
dt("setSec",D,N)                  -- setzt die Sekunde  (Rückgabe float D)
dt("setMilliSec",D,N)             -- setzt die Millisekunde  (Rückgabe float D)
*/



/* Neu hinzugefügt: */
Var int dt_VAR_Beginning_of_the_Week = 1   // Mo
Var int dt_VAR_Weekend_Days_one_Week = 2   // Sa + So

/* Neu hinzugefügt:
dt_VAR_Beginning_of_the_Week = 1   -- 1..7, 1=Mo
                                   -- Steuert die folgenden Wochenfunktionen: (so kann der Wochenstart z.B. in USA auf 7=Sonntag verlegt werden)
                                     - dt("BoW"..., dt("EoW"...
dt_VAR_Weekend_Days_one_Week = 2   -- 1..x, So,Sa,Fr,...
                                     - dt("isWeekend"..., dt("isWorkday"..., dt("NextWorkday"..., dt("PrevWorkday"..., dt("Sum_Workdays"...


dt("Advent4",Jahr)                -- ermittelt Datum des 4. Advent als Zeitpunkt  (Rückgabe float D)
dt("Advent4",D)                   -- ermittelt Datum des 4. Advent als Zeitpunkt  (Rückgabe float D)
dt("Easter",Jahr)                 -- ermittelt Datum des Ostersonntages als Zeitpunkt  (Rückgabe float D)
dt("Easter",D)                    -- ermittelt Datum des Ostersonntages als Zeitpunkt  (Rückgabe float D)

dt("BoM",D)                       -- ermittelt den Beginn des Monats (Beginning of Month)  (Zeitpunkt)  (Rückgabe float D)
dt("EoM",D)                       -- ermittelt das Ende des Monats (End of Month)  (Zeitpunkt)  (Rückgabe float D)

dt("LastDayInMonth",M,Y)          -- ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (M,Y)  (Rückgabe 1..31)
dt("LastDayInMonth",D)            -- ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (Zeitpunkt)  (Rückgabe 1..31)

dt("Ultimo",M,Y)                  -- ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (M,Y)  (Rückgabe float D)
dt("Ultimo",D)                    -- ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (Zeitpunkt)  (Rückgabe float D)

dt("BoQ",D)                       -- ermittelt den ersten Tag des Quartals des Datums ( 1.1. /  1.4. /  1.7. /  1.10.) (Beginning of Quarter)  (Zeitpunkt)  (Rückgabe float D)
dt("BoQ",Y,QNr)                   -- ermittelt den ersten Tag des Quartals aus der Quartalsnummer ( 1..4 ) (Beginning of Quarter)  (Y,QNr)  (Rückgabe float D)

dt("EoQ",D)                       -- ermittelt den letzten Tag des Quartals des Datums (31.3. / 30.4. / 30.9. / 31.12.) (End of Quarter)  (Zeitpunkt)  (Rückgabe float D)
dt("EoQ",Y,QNr)                   -- ermittelt den letzten Tag des Quartals aus der Quartalsnummer ( 1..4 ) (End of Quarter)  (Y,QNr)  (Rückgabe float D)

dt("BoW",D)                       -- ermittelt den Wochenbeginn (Beginning of Week) (beachtet dt_VAR_Beginning_of_the_Week)  (Zeitpunkt)  (Rückgabe float D)

dt("EoW",D)                       -- ermittelt das Wochenende (End of Week) (beachtet dt_VAR_Beginning_of_the_Week)  (Zeitpunkt)  (Rückgabe float D)

dt("BoY",D)                       -- ermittelt den Jahresbeginn ( 1. 1.) (Beginning of Year)  (Zeitpunkt)  (Rückgabe float D)

dt("EoY",D)                       -- ermittelt das Jahresende   (31.12.) (End of Year)  (Zeitpunkt)  (Rückgabe float D)

dt("WeekdayStep",D,"Mode")        -- ermittelt auf Wochentag korrigiertes Datum  (Rückgabe float D)

dt("DateAdd",D,Da,We,Mo,Y)        -- Addiere (oder subtrahiere) Tage,Wochen,Monate und Jahre von/zum Zeitpunkt D!.  (Zeitpunkt)  (Rückgabe float D)
dt("NextWorkday",D)               -- Liefert das Datum des nächsten Werktages  (beachtet dt_VAR_Weekend_Days_one_Week).  (Zeitpunkt)  (Rückgabe float D)
dt("PrevWorkday",D)               -- Liefert das Datum des vorherigen Werktages  (beachtet dt_VAR_Weekend_Days_one_Week).  (Zeitpunkt)  (Rückgabe float D)

dt("Yesterday")                   -- liefert den gestrigen Tag  (!now-1)  (Rückgabe float D)
dt("Today")                       -- liefert den heutigen Tag  (!now)  (Rückgabe float D)
dt("Tomorrow")                    -- liefert den morgigen Tag  (!now+1)  (Rückgabe float D)

dt("NtoD",D)                      -- NToD  wie  CToD$(), aber mit Zeitpunkten (D! -> "YYYYMMDD")  (Rückgabe long  YYYYMMDD)    Datenfeld$ = Str$(dt("NtoD",D))
dt("DtoN",S)                      -- DToN  wie  DToC$(), aber mit Zeitpunkten ("YYYYMMDD" -> D!)  (Rückgabe float D)           Datum! = dt("DtoN",Val(Datenfeld$))

dt("ActualDay")                   -- ermittelt den aktuellen Tag  (Rückgabe 1..31)
dt("ActualMonth")                 -- ermittelt den aktuellen Monat  (Rückgabe 1..12)
dt("ActualYear")                  -- ermittelt das aktuelle Jahr  (Rückgabe 1600..3999)

dt("Quarter",D)                   -- ermittelt die QuartalsNr des Datums  (Zeitpunkt)  (Rückgabe 1..4)
dt("Quarter",S)                   -- ermittelt die QuartalsNr des Datums  ("dd.mm.yyyy")  (Rückgabe 1..4)
dt("Quarter",Da,M,Y)              -- ermittelt die QuartalsNr des Datums  (Da,M,Y)  (Rückgabe 1..4)

dt("DiffDate",DA!,DB!,*D,*M,*Y)   -- Differenz zweier Daten als Tage,Monate,Jahre und Tagessumme.  (Zeitpunkt)  (Rückgabe quadint)

dt("isWeekend",D)                 -- vergleicht Wochentag (Mo..So) auf Wochenende (beachtet dt_VAR_Weekend_Days_one_Week)  (Rückgabe 0..1)
dt("isWorkday",D)                 -- vergleicht Wochentag (Mo..So) auf Arbeitstag (beachtet dt_VAR_Weekend_Days_one_Week)  (Rückgabe 0..1)
dt("Sum_Workdays",D1!,D2!,*WE)    -- summiert Wochentage/Wochenenden zweier Daten (beachtet dt_VAR_Weekend_Days_one_Week)  (Rückgabe long, ptr to long)
*/








/* alle 65 dt-Funktionen dann sortiert:
dt_VAR_Beginning_of_the_Week = 1   -- 1..7, 1=Mo
                                   -- Steuert die folgenden Wochenfunktionen: (so kann der Wochenstart z.B. in USA auf 7=Sonntag verlegt werden)
                                     - dt("BoW"..., dt("EoW"...
dt_VAR_Weekend_Days_one_Week = 2   -- 1..x, So,Sa,Fr,...
                                     - dt("isWeekend"..., dt("isWorkday"..., dt("NextWorkday"..., dt("PrevWorkday"..., dt("Sum_Workdays"...

dt("ActualDay")                   --* ermittelt den aktuellen Tag  (Rückgabe 1..31)
dt("ActualMonth")                 --* ermittelt den aktuellen Monat  (Rückgabe 1..12)
dt("ActualYear")                  --* ermittelt das aktuelle Jahr  (Rückgabe 1600..3999)
dt("Advent4",D!)                  --* ermittelt Datum des 4. Advent als Zeitpunkt  (Rückgabe float D)
dt("Advent4",Jahr%)               --* ermittelt Datum des 4. Advent als Zeitpunkt  (Rückgabe float D)
dt("BoM",D)                       --* ermittelt den Beginn des Monats (Beginning of Month)  (Zeitpunkt)  (Rückgabe float D)
dt("BoQ",D)                       --* ermittelt den ersten Tag des Quartals des Datums ( 1.1. /  1.4. /  1.7. /  1.10.) (Beginning of Quarter)  (Zeitpunkt)  (Rückgabe float D)
dt("BoQ",Da.M.Y)                  --* ermittelt den ersten Tag des Quartals des Datums ( 1.1. /  1.4. /  1.7. /  1.10.) (Beginning of Quarter)  (Da,M,Y)  (Rückgabe float D)
dt("BoQ",S)                       --* ermittelt den ersten Tag des Quartals des Datums ( 1.1. /  1.4. /  1.7. /  1.10.) (Beginning of Quarter)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("BoQ",Y,QNr)                   --* ermittelt den ersten Tag des Quartals aus der Quartalsnummer ( 1..4 ) (Beginning of Quarter)  (Y,QNr)  (Rückgabe float D)
dt("BoW",D)                       --* ermittelt den Wochenbeginn (Beginning of Week) (beachtet dt_VAR_Beginning_of_the_Week)  (Zeitpunkt)  (Rückgabe float D)
dt("BoW",Da,M,Y)                  --* ermittelt den Wochenbeginn (Beginning of Week) (beachtet dt_VAR_Beginning_of_the_Week)  (Da,M,Y)  (Rückgabe float D)
dt("BoW",S)                       --* ermittelt den Wochenbeginn (Beginning of Week) (beachtet dt_VAR_Beginning_of_the_Week)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("BoY",D)                       --* ermittelt den Jahresbeginn ( 1. 1.) (Beginning of Year)  (Zeitpunkt)  (Rückgabe float D)
dt("BoY",Da,M,Y)                  --* ermittelt den Jahresbeginn ( 1. 1.) (Beginning of Year)  (Da,M,Y)  (Rückgabe float D)
dt("BoY",S)                       --* ermittelt den Jahresbeginn ( 1. 1.) (Beginning of Year)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("Compare",D1,D2)               --  vergleicht zwei Zeitpunkte  (Rückgabe signum)
dt("CompareDate",D1,D2)           --  vergleicht zwei Datumswerte  (Rückgabe signum)
dt("CompareTime",D1,D2)           --  vergleicht zwei Uhrzeiten  (Rückgabe signum)
dt("DateAdd",D,Da,We,Mo,Y)        --* Addiere (oder subtrahiere) Tage,Wochen,Monate und Jahre von/zum Zeitpunkt D!.  (Zeitpunkt)  (Rückgabe float D)
dt("DateTimeStr",S[,D])           --  foramtierte Ausgabe von Datum und Zeit  (Rückgabe string)
dt("DaysBetween",D1,D2)           --  Tage zwischen zwei Datumswerten  (Rückgabe int)
dt("DiffDate",DA!,DB!,*D,*M,*Y)   --* Differenz zweier Daten als Tage,Monate,Jahre und Tagessumme.  (Zeitpunkt)  (Rückgabe quadint)
dt("DtoN",S)                      --* DToN  wie  DToC$(), aber mit Zeitpunkten ("YYYYMMDD" -> D!)  (Rückgabe float D)           Datum! = dt("DtoN",Val(Datenfeld$))
dt("Easter",Jahr)                 --* ermittelt Datum des Ostersonntages als Zeitpunkt  (Rückgabe float D)
dt("EoM",D)                       --* ermittelt das Ende des Monats (End of Month)  (Zeitpunkt)  (Rückgabe float D)
dt("EoQ",D)                       --* ermittelt den letzten Tag des Quartals des Datums (31.3. / 30.4. / 30.9. / 31.12.) (End of Quarter)  (Zeitpunkt)  (Rückgabe float D)
dt("EoQ",Da,M,Y)                  --* ermittelt den letzten Tag des Quartals des Datums (31.3. / 30.4. / 30.9. / 31.12.) (End of Quarter)  (Da,M,Y)  (Rückgabe float D)
dt("EoQ",S)                       --* ermittelt den letzten Tag des Quartals des Datums (31.3. / 30.4. / 30.9. / 31.12.) (End of Quarter)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("EoQ",Y,QNr)                   --* ermittelt den letzten Tag des Quartals aus der Quartalsnummer ( 1..4 ) (End of Quarter)  (Y,QNr)  (Rückgabe float D)
dt("EoW",D)                       --* ermittelt das Wochenende (End of Week) (beachtet dt_VAR_Beginning_of_the_Week)  (Zeitpunkt)  (Rückgabe float D)
dt("EoW",Da,M,Y)                  --* ermittelt das Wochenende (End of Week) (beachtet dt_VAR_Beginning_of_the_Week)  (Da,M,Y)  (Rückgabe float D)
dt("EoW",S)                       --* ermittelt das Wochenende (End of Week) (beachtet dt_VAR_Beginning_of_the_Week)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("EoY",D)                       --* ermittelt das Jahresende   (31.12.) (End of Year)  (Zeitpunkt)  (Rückgabe float D)
dt("EoY",Da,M,Y)                  --* ermittelt das Jahresende   (31.12.) (End of Year)  (Da,M,Y)  (Rückgabe float D)
dt("EoY",S)                       --* ermittelt das Jahresende   (31.12.) (End of Year)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("getDate",N[,D])               --  ermittelt das Datum in verschiedenen Schreibweisen  (Rückgabe string)
dt("getDay",D)                    --  ermittelt den Tag eines Zeitpunktes  (Rückgabe int)
dt("getDoW",D)                    --  ermittelt den Wochentag eines Zeitpunktes  (Rückgabe 1..7, 1=Mo)
dt("getDoY",D)                    --  ermittelt den Tag im Jahr eines Zeitpunktes  (Rückgabe 1..366)
dt("getHour",D)                   --  ermittelt die Stunde eines Zeitpunktes  (Rückgabe int)
dt("getMilliSec",D)               --  ermittelt die MilliSekunde eines Zeitpunktes  (Rückgabe int)
dt("getMin",D)                    --  ermittelt die Minute eines Zeitpunktes  (Rückgabe int)
dt("getMonth",D)                  --  ermittelt den Monat eines Zeitpunktes  (Rückgabe int)
dt("getSec",D)                    --  ermittelt die Sekunde eines Zeitpunktes  (Rückgabe int)
dt("getTime",N[,D])               --  ermittelt die Uhrzeit in verschiedenen Schreibweisen  (Rückgabe string)
dt("getWoY",D)                    --  ermittelt die Jahreswoche eines Zeitpunktes  (Rückgabe 1..53)
dt("getYear",D)                   --  ermittelt das Jahr eines Zeitpunktes  (Rückgabe int)
dt("incDay",D,N)                  --  erhöht den Tag  (Rückgabe float D)
dt("incHour",D,N)                 --  erhöht die Stunden  (Rückgabe float D)
dt("incMin",D,N)                  --  erhöht die Minuten  (Rückgabe float D)
dt("incMonth",D,N)                --  erhöht die Monate  (Rückgabe float D)
dt("incSec",D,N)                  --  erhöht die Sekunden  (Rückgabe float D)
dt("incYear",D,N)                 --  erhöht das Jahr  (Rückgabe float D)
dt("IsLeapYear",D)                --  prüft auf Schaltjahr  (Rückgabe 0..1)
dt("isWeekend",D)                 --* vergleicht Wochentag (Mo..So) auf Wochenende (beachtet dt_VAR_Weekend_Days_one_Week)  (Rückgabe 0..1)
dt("isWorkday",D)                 --* vergleicht Wochentag (Mo..So) auf Arbeitstag (beachtet dt_VAR_Weekend_Days_one_Week)  (Rückgabe 0..1)
dt("LastDayInMonth",D)            --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (Zeitpunkt)  (Rückgabe 1..31)
dt("LastDayInMonth",Da,M,Y)       --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (Da,M,Y)  (Rückgabe 1..31)
dt("LastDayInMonth",M,Y)          --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (M,Y)  (Rückgabe 1..31)
dt("LastDayInMonth",S)            --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  ("dd.mm.yyyy")  (Rückgabe 1..31)
dt("NextWorkday",D)               --* Liefert das Datum des nächsten Werktages  (beachtet dt_VAR_Weekend_Days_one_Week).  (Zeitpunkt)  (Rückgabe float D)
dt("NtoD",D)                      --* NToD  wie  CToD$(), aber mit Zeitpunkten (D! -> "YYYYMMDD")  (Rückgabe long  YYYYMMDD)    Datenfeld$ = Str$(dt("NtoD",D))
dt("PrevWorkday",D)               --* Liefert das Datum des vorherigen Werktages  (beachtet dt_VAR_Weekend_Days_one_Week).  (Zeitpunkt)  (Rückgabe float D)
dt("Quarter",D)                   --* ermittelt die QuartalsNr des Datums  (Zeitpunkt)  (Rückgabe 1..4)
dt("Quarter",Da,M,Y)              --* ermittelt die QuartalsNr des Datums  (Da,M,Y)  (Rückgabe 1..4)
dt("Quarter",S)                   --* ermittelt die QuartalsNr des Datums  ("dd.mm.yyyy")  (Rückgabe 1..4)
dt("setDate",S[,D])               --  setzt das Datum  (Rückgabe float D)
dt("setDate",y,m,d[,D])           --  setzt das Datum  (Rückgabe float D)
dt("setDateTime",y,m,d,h,n,s,ms)  --  setzt den Zeitpunkt  (Rückgabe float D)
dt("setDay",D,N)                  --  setzt den Tag  (Rückgabe float D)
dt("setHour",D,N)                 --  setzt die Stunde  (Rückgabe float D)
dt("setMilliSec",D,N)             --  setzt die Millisekunde  (Rückgabe float D)
dt("setMin",D,N)                  --  setzt die Minute  (Rückgabe float D)
dt("setMonth",D,N)                --  setzt den Monat  (Rückgabe float D)
dt("setSec",D,N)                  --  setzt die Sekunde  (Rückgabe float D)
dt("setTime",h,n,s,ms[,D])        --  setzt die Uhrzeit  (Rückgabe float D)
dt("setTime",S[,D])               --  setzt die Uhrzeit  (Rückgabe float D)
dt("setYear",D,N)                 --  setzt das Jahr  (Rückgabe float D)
dt("Sum_Workdays",D1!,D2!,*WE)    --* summiert Wochentage/Wochenenden zweier Daten (beachtet dt_VAR_Weekend_Days_one_Week)  (Rückgabe long, ptr to long)
dt("Today")                       --* liefert den heutigen Tag  (!now)  (Rückgabe float D)
dt("Tomorrow")                    --* liefert den morgigen Tag  (!now+1)  (Rückgabe float D)
dt("Ultimo",D)                    --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (Zeitpunkt)  (Rückgabe float D)
dt("Ultimo",Da,M,Y)               --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (Da,M,Y)  (Rückgabe float D)
dt("Ultimo",M,Y)                  --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  (M,Y)  (Rückgabe float D)
dt("Ultimo",S)                    --* ermittelt Ultimo-Tag des Monats (letzter Tag des Monats)  ("dd.mm.yyyy")  (Rückgabe float D)
dt("WeekdayStep",D,"Mode")        --* ermittelt auf Wochentag korrigiertes Datum  (Rückgabe float D)
dt("Yesterday")                   --* liefert den gestrigen Tag  (!now-1)  (Rückgabe float D)
*/






/*
Ermittlung des 4. Advent.
Hieraus ergeben sich dann die folgenden Daten:
-- dt("Advent4",Jahr%)		= 4. Advent
-- dt("Advent4",Jahr%) - 7	= 3. Advent
-- dt("Advent4",Jahr%) - 14	= 2. Advent
-- dt("Advent4",Jahr%) - 21	= 1. Advent
-- dt("Advent4",Jahr%) - 28	= Totensonntag
-- dt("Advent4",Jahr%) - 32	= Buß- und Bettag
-- dt("Advent4",Jahr%) - 35	= Volkstrauertag
(Rückgabe float D)
*/
SubProc dt.Advent4
   If PType$(1) = "!"
      Parameters float D
      D = dt("SetDay",D,25)
      D = dt("SetMonth",D,12)
      Return ( D - dt("GetDoW",D) )
   Else
      Parameters int Jahr
      Declare float Tag2512
      Tag2512 = dt("SetDate", Jahr, 12, 25 )
      Return ( Tag2512 - dt("GetDoW",Tag2512) )
   EndIf
EndProc


/*
Ermittlung des Ostersonntages.
Hieraus ergeben sich dann die folgenden Daten:
-- oSo = dt("Easter",Jahr%)      	= OsterSo
-- (weitere siehe Kalender(): sind zu viele für hier)
(Rückgabe float D)
*/
SubProc dt.Easter
   Declare int Y
   If PType$(1) = "!"
      Parameters float Df
      Y = dt("getYear",Df)
   Else
      Parameters int Jahr
      Y = Jahr
   EndIf
   Declare int D,Mo, Century, r19, r30, x,x1,x2,x3,x4,x5
   Century = Y \ 100
   r19 = Y mod 19
   x = ((Century - 15) >> 1) + 202 - r19 * 11
   Select Century
      CaseOf 21,24,25,27,28,29,30,31,32,34,35,38
         Dec x
      CaseOf 33,36,37,39,40
         Dec x, 2
   EndSelect
   r30 = x mod 30
   x1 = r30 + 21
   Case r30 == 29 : Dec x1
   Case (r30 == 28) and (r19 > 10) : Dec x1
   x2 = (x1 - 19) mod 7
   x3 = (40 - Century) mod 4
   Case x3 == 3 : Inc x3
   Case x3 > 1 : Inc x3
   x = Y mod 100
   x4 = (x + x / 4) mod 7
   x5 = ((20 - x2 - x3 - x4) mod 7) + 1
   D = x1 + x5
   Mo = 3
   If D > 31
      Dec D,31
      Inc Mo
   EndIf
   Return dt("SetDate", Y,Mo,D)
EndProc


/* BoM - Beginning of Month 
   float D = dt("BoM", float D)   // Zeitpunkt
(Rückgabe float D)
*/
SubProc dt.BoM
   Parameters float D
   Return dt("SetDay",D,1)
EndProc


/* EoM - End of Month 
   float D = dt("EoM", float D)   // Zeitpunkt
(Rückgabe float D)
*/
SubProc dt.EoM
   Parameters float D
   Return dt("Ultimo",D)
EndProc


/* LastDayInMonth
   int Day = dt("LastDayInMonth", int Month,Year)   // M,Y
   int Day = dt("LastDayInMonth", float D)   // Zeitpunkt

LastDayInMonth: liefert den Tag
Ultimo: liefert den Zeitpunkt
*/
SubProc dt.LastDayInMonth
   Declare float D
   If %PCount = 2
      Parameters int Month,Year
      D = dt("setDate",Year,Month,1)
   Else
      Parameters float D1
      D = D1
   EndIf
   // -----
   Case dt("GetMonth",D) = 12 : Return 31
   // (01. MM+1. YYYY) -1
   D = dt("SetDay",D, 1)
   D = dt("SetMonth",D, dt("GetMonth",D) + 1)
   D = dt("incDay",D, -1)
   Return dt("GetDay",D)
EndProc


/* Ultimo
   float D = dt("Ultimo", int Month,Year)   // M,Y
   float D = dt("Ultimo", float D)   // Zeitpunkt

LastDayInMonth: liefert den Tag
Ultimo: liefert den Zeitpunkt
*/
SubProc dt.Ultimo
   Declare float D
   If %PCount = 2
      Parameters int Month,Year
      D = dt("setDate",Year,Month,1)
   Else
      Parameters float D1
      D = D1
   EndIf
   // -----
   If dt("GetMonth",D) = 12
      D = dt("SetDay",D, 31)
      Return D
   EndIf
   // (01. MM+1. YYYY) -1
   D = dt("SetDay",D, 1)
   D = dt("SetMonth",D, dt("GetMonth",D) + 1)
   D = dt("incDay",D, -1)
   Return D
EndProc


/* Quarter 
(Rückgabe 1..4)
*/
SubProc dt.Quarter
   Parameters float D
   Return Int((dt("GetMonth",D) - 1) / 3) + 1
EndProc


/* Beginning of Quarter 
(Rückgabe float D)
*/
SubProc dt.BoQ
   Declare int PC, string PT
   Declare float D
   Declare int Mo
   PC = %PCount
   PT = PType$(1)
   If PC = 1
      Parameters float D1
      D = D1
   ElseIf PC = 2
      Parameters int QYear, QuarterNo
      CaseNot Between(QuarterNo,1,4) : QuarterNo = 1
      Mo = QuarterNo * 3 - 2
      Return dt("setDate",QYear,Mo,1)
   EndIf
   // -----
   Mo = dt("GetMonth",D) - 1
   D  = dt("SetDay",D,1)
   Return dt("SetMonth",D,((Mo \ 3) + 1) * 3 - 2)
EndProc


/* End of Quarter 
(Rückgabe float D)
*/
SubProc dt.EoQ
   Declare int PC, string PT
   Declare float D
   Declare int Mo
   PC = %PCount
   PT = PType$(1)
   If PC = 1
      Parameters float D1
      D = D1
   ElseIf PC = 2
      Parameters int QYear, QuarterNo
      CaseNot Between(QuarterNo,1,4) : QuarterNo = 1
      Mo = QuarterNo * 3
      Return dt("Ultimo",Mo,QYear)
   EndIf
   // -----
   Mo = dt("GetMonth",D) - 1
   D  = dt("SetDay",D,1)
   Return dt("SetMonth",D,((Mo \ 3) + 1) * 3)
EndProc


/* BoW - Beginning of Week     // 1..7, 1=Mo
   float D = dt("BoW", float D)   // Zeitpunkt

   Ermittelt aus dem Datum den Wochenbeginn.
      Beachtet die Variable: dt_VAR_Beginning_of_the_Week
      Dadurch kann der Wochenstart je nach Land angepasst werden.
*/
SubProc dt.BoW
   Parameters float D
   Declare int wd
   wd = dt("getDoW",D)
   While wd <> dt_VAR_Beginning_of_the_Week
      D = D - 1
      Dec wd
      Case wd < 1 : wd = 7
   EndWhile
   Return D
EndProc


/* EoW - End of Week     // 1..7, 1=Mo
   float D = dt("EoW", float D)   // Zeitpunkt

   Ermittelt aus dem Datum das Wochenende.
      Beachtet die Variable: dt_VAR_Beginning_of_the_Week
      Dadurch kann Wochenende je nach Land angepasst werden.
*/
SubProc dt.EoW
   Parameters float D
   Declare int wd, we
   wd = dt("getDoW",D)
   we = dt_VAR_Beginning_of_the_Week - 1
   Case we < 1 : we = 7
   While wd <> we
      D = D + 1
      Inc wd
      Case wd > 7 : wd = 1
   EndWhile
   Return D
EndProc


/* Beginning of Year */
SubProc dt.BoY
   Parameters float D
   Return dt("SetDate",dt("GetYear",D),1,1)
EndProc


/* End of Year */
SubProc dt.EoY
   Parameters float D
   Return dt("SetDate",dt("GetYear",D),12,31)
EndProc


/* NToD  wie  CToD$(), aber mit Zeitpunkten (D! -> YYYYMMDD) */
SubProc dt.NToD
   Parameters float D
   Return dt("GetYear",D) * 10000 + dt("GetMonth",D) * 100 + dt("GetDay",D)
EndProc


/* DToN  wie  DToC$(), aber mit Zeitpunkten (YYYYMMDD -> D!) */
SubProc dt.DToN
   Parameters long L
   Declare float D
   D = dt("SetYear", D, L \ 10000)
   D = dt("SetMonth",D, (L mod 10000) \ 100)
   D = dt("SetDay",  D, L mod 100)
   Return D
EndProc


/* ActualDay
   Liefert den aktuellen Tag.
*/
SubProc dt.ActualDay
   Return dt("GetDay",!now)
EndProc


/* ActualMonth
   Liefert den aktuellen Monat.
*/
SubProc dt.ActualMonth
   Return dt("GetMonth",!now)
EndProc


/* ActualYear
   Liefert das aktuelle Jahr.
*/
SubProc dt.ActualYear
   Return dt("GetYear",!now)
EndProc


/* DateAdd
   float D = DateAdd( float D, long Days,Weeks,Months,Years )
   Addiere (oder subtrahiere) Tage,Wochen,Monate und Jahre von/zum Zeitpunkt D!.
*/
SubProc dt.DateAdd
   Parameters float D1, long aDays,aWeeks,aMonths,aYears
   Declare long N, D,M,Y, i, d28, float D2
   i = dt("D2N",D1,Addr(D),Addr(M),Addr(Y))
   If (aMonths = 0) and (aYears = 0)
      i = i + aDays + (aWeeks * 7)
   Else
      If D > 28
         D28 = D - 28
         D = 28
      EndIf
      Inc Y,aYears
      Inc Y,(aMonths \ 12)
      Inc M,(aMonths mod 12)
      While (M < 1)
         Inc M,12
         Dec Y
      EndWhile
      While (M > 12)
         Dec M,12
         Inc Y
      EndWhile
      D2 = dt("setDate",Y,M,D)
      i = dt("D2N",D2,Addr(D),Addr(M),Addr(Y))
      If i <> -1
         i = i + (d28 + aDays)
         i = i + (aWeeks * 7)
      EndIf
   EndIf
   Return dt("N2D",i,Addr(D),Addr(M),Addr(Y))
EndProc


/* DiffDate
   DiffDate( float DA,DB, pointer Days,Months,Years )
   Liefert die Differenz von zwei Daten als D,M,Y.
   (und als Rückgabewert in Tagen)
*/
SubProc dt.DiffDate
   Parameters float DA,DB, pointer ptr_Days, ptr_Months, ptr_Years
   Declare quadint erg, long N1,N2, D,M,Y, D1,M1,Y1, D2,M2,Y2

   If DA > DB
      N2 = dt("D2N",DB,Addr(D1),Addr(M1),Addr(Y1))
      N1 = dt("D2N",DA,Addr(D2),Addr(M2),Addr(Y2))
      erg = N1 - N2
   Else
      N1 = dt("D2N",DA,Addr(D1),Addr(M1),Addr(Y1))
      N2 = dt("D2N",DB,Addr(D2),Addr(M2),Addr(Y2))
      erg = N2 - N1
   EndIf

   If D2 < D1
      Dec M2
      If M2 < 1
         Inc M2,12
         Dec Y2
      EndIf
      Inc D2, dt("LastDayInMonth",M2,Y2)
   EndIf
   D = D2 - D1

   If M2 < M1
      Inc M2,12
      Dec Y2
   EndIf
   M = M2 - M1
   Y = Y2 - Y1

   Case ptr_Days   : Long ptr_Days,0   = D
   Case ptr_Months : Long ptr_Months,0 = M
   Case ptr_Years  : Long ptr_Years,0  = Y

   Return erg
EndProc


/* getDoW_Str
   D = Datum
   L = 1-kurz, 2-Lang
   sprache: "de", "en", "eo", "es", "it", "fr", "nl"
*/
SubProc dt.getDoW_Str
   Parameters float D, int laenge, string sprache
   Declare int wd, string S, L,k
   wd = dt("getDoW",D)
   Select lower$(sprache)
   caseof "de"
     L = "Montag,Dienstag,Mittwoch,Donnerstag,Freitag,Samstag,Sonntag" 'deutsch
     k = "Mo,Di,Mi,Do,Fr,Sa,So"
   caseof "en"
     L = "Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday" 'englisch
     k = "Mo,Tu,We,Th,Fr,Sa,Su"
   caseof "eo"
     L = "lundo,mardo,merkredo,jaudo,vendredo,sabato,dimanco" 'Esperanto
     k = "?1,?2,?3,?4,?5,?6,?7"
   caseof "es"
     L = "lunes,martes,miércoles,jueves,viernes,sÃ	bado,domingo" 'Spanisch
     k = "?1,?2,?3,?4,?5,?6,?7"
   caseof "it"
     L = "lunedì,martedì,mercoledì,giovedì,venerdì,sabato,domenica" 'Italienisch
     k = "?1,?2,?3,?4,?5,?6,?7"
   caseof "fr"
     L = "lundi,mardi,mercredi,jeudi,vendredi,samedi,dimanche" 'Französisch
     k = "?1,?2,?3,?4,?5,?6,?7"
   caseof "nl"
     L = "maandag,dinsdag,woensdag,donderdag,vrijdag,zaterdag,zondag" 'Niederländisch
     k = "?1,?2,?3,?4,?5,?6,?7"
   otherwise
     L = "Montag,Dienstag,Mittwoch,Donnerstag,Freitag,Samstag,Sonntag" 'deutsch
     k = "Mo,Di,Mi,Do,Fr,Sa,So"
   EndSelect
   S = SubStr$(if(laenge=1,k,L), wd, ",")
   Return S
EndProc


/* isWeekend
   int bool = dt("isWeekend", D! )
   Beachtet:  dt_VAR_Weekend_Days_one_Week     Weekday -> Wochenende?
*/
SubProc dt.isWeekend
   Parameters float D
   Declare int wd, ok
   ok = 0
   wd = dt("getDoW",D)
   Select wd
      CaseOf 1 'Mo
         Case dt_VAR_Weekend_Days_one_Week >= 7 : Ok = 1
      CaseOf 2 'Di
         Case dt_VAR_Weekend_Days_one_Week >= 6 : Ok = 1
      CaseOf 3 'Mi
         Case dt_VAR_Weekend_Days_one_Week >= 5 : Ok = 1
      CaseOf 4 'Do
         Case dt_VAR_Weekend_Days_one_Week >= 4 : Ok = 1
      CaseOf 5 'Fr
         Case dt_VAR_Weekend_Days_one_Week >= 3 : Ok = 1
      CaseOf 6 'Sa
         Case dt_VAR_Weekend_Days_one_Week >= 2 : Ok = 1
      CaseOf 7 'So
         Case dt_VAR_Weekend_Days_one_Week >= 1 : Ok = 1
   EndSelect
   Return ok
EndProc


/* isWorkday
   int bool = dt("isWorkday", D! )
   Beachtet:  dt_VAR_Weekend_Days_one_Week     Weekday -> Wochenende?
*/
SubProc dt.isWorkday
   Parameters float D
   Declare int wd, ok
   ok = 0
   wd = dt("getDoW",D)
   Select wd
      CaseOf 1 'Mo
         Case dt_VAR_Weekend_Days_one_Week < 7 : Ok = 1
      CaseOf 2 'Di
         Case dt_VAR_Weekend_Days_one_Week < 6 : Ok = 1
      CaseOf 3 'Mi
         Case dt_VAR_Weekend_Days_one_Week < 5 : Ok = 1
      CaseOf 4 'Do
         Case dt_VAR_Weekend_Days_one_Week < 4 : Ok = 1
      CaseOf 5 'Fr
         Case dt_VAR_Weekend_Days_one_Week < 3 : Ok = 1
      CaseOf 6 'Sa
         Case dt_VAR_Weekend_Days_one_Week < 2 : Ok = 1
      CaseOf 7 'So
         Case dt_VAR_Weekend_Days_one_Week < 1 : Ok = 1
   EndSelect
   Return ok
EndProc


/* NextWorkday
   D! = dt("NextWorkday",D!)
   Liefert das Datum des nächsten Werktages (isWorkday(): überspringe isWeekend()).
   Beachtet:  dt_VAR_Weekend_Days_one_Week
*/
SubProc dt.NextWorkday
   Parameters float D
   Declare int wd
   wd = dt("getDoW",D)
   Repeat
      D = D + 1
      Inc wd
      Case wd > 7 : wd = 1
   Until dt("isWorkday",D)
   Return D
EndProc


/* PrevWorkday
   D! = dt("PrevWorkday",D!)
   Liefert das Datum des vorherigen Werktages (isWorkday(): überspringe isWeekend()).
   Beachtet:  dt_VAR_Weekend_Days_one_Week
*/
SubProc dt.PrevWorkday
   Parameters float D
   Declare int wd
   wd = dt("getDoW",D)
   Repeat
      D = D - 1
      Dec wd
      Case wd < 1 : wd = 7
   Until dt("isWorkday",D)
   Return D
EndProc


/* Sum_Workdays
   Workdays = dt("Sum_Workdays",D1!,D2!, pointer ptr_Weekends )
   Liefert die Summe der Werktage/Wochenendtage zwischen 2 Daten
   Beachtet:  dt_VAR_Weekend_Days_one_Week
*/
SubProc dt.Sum_Workdays
   Parameters float D1,D2, pointer ptr_Weekends
   Declare float tmpf, D, long sum_WD, sum_WE, tmp, wks
   Clear sum_WD, sum_WE
   If D1 > D2
      tmpf = D1
      D1 = D2
      D2 = tmpf
   EndIf

   // Die Tage vor dem Startdatum
   D = dt("BoW",D1)
   If D <> D1
      tmpf = D
      WhileLoop Int(D1 - D)
         If dt("isWorkday",tmpf)
            Dec sum_WD
         Else
            Dec sum_WE
         EndIf
         tmpf = tmpf + 1
      EndWhile
   EndIf
   D1 = D

   // Die Tage nach dem Enddatum
   D = dt("EoW",D2)
   If D <> D2
      tmpf = D
      WhileLoop Int(D - D2)
         If dt("isWorkday",tmpf)
            Dec sum_WD
         Else
            Dec sum_WE
         EndIf
         tmpf = tmpf - 1
      EndWhile
   EndIf
   D2 = D

   wks = Int(D2 - D1 + 1) \ 7
   sum_WE = sum_WE + (wks * dt_VAR_Weekend_Days_one_Week)
   sum_WD = sum_WD + (wks * (7 - dt_VAR_Weekend_Days_one_Week))
   Case sum_WE < 0 : Inc sum_WE,7
   Case sum_WD < 0 : Inc sum_WD,7

   Case ptr_Weekends : Long ptr_Weekends,0 = sum_WE
   Return sum_WD
EndProc


/* Yesterday
liefert den gestrigen Tag  (!now-1)  (Rückgabe float D)
*/
SubProc dt.Yesterday
   Return !now - 1
EndProc


/* Today
liefert den heutigen Tag  (!now)  (Rückgabe float D)
*/
SubProc dt.Today
   Return !now
EndProc


/* Tomorrow
liefert den morgigen Tag  (!now+1)  (Rückgabe float D)
*/
SubProc dt.Tomorrow
   Return !now + 1
EndProc


/* Upro f. Umrechnung D_float -> D_N
   D! -> N
   N = dt("D2N",D!,Addr(D),Addr(M),Addr(Y))
*/
SubProc dt.D2N
   Parameters float D1, pointer pD,pM,pY
   Declare long D,M,Y
   Y = dt("getYear",D1)
   M = dt("getMonth",D1)
   D = dt("getDay",D1)
   Case pY : Long pY,0 = Y
   Case pM : Long pM,0 = M
   Case pD : Long pD,0 = D
   Var long N = -1
   If Between(Y,1600,3999, M,1,12, D,1,dt("LastDayInMonth",M,Y))
      If (Y = 1600) and (M < 3)
         Case M = 2 : Inc D,31
         Dec D
         N = D
      Else
         N = D
         If M > 2
            Dec M,3
         Else
            Inc M,9
            Dec Y
         EndIf
         Y = Y - 1600
         N = N + 59 + (((Y \ 100) * 146097) >> 2) + (((Y mod 100) * 1461) >> 2) + ((M * 153 + 2) \ 5)
      EndIf
   EndIf
   Return N
EndProc


/* Upro f. Umrechnung D:N -> D_float
   N -> D!
   D! = dt("N2D",N,Addr(D),Addr(M),Addr(Y))
*/
SubProc dt.N2D
   Parameters long N, pointer pD,pM,pY
   Declare long D,M,Y,i,j
   If N > 59
      i = ((N - 59) << 2) - 1
      j = (((i mod 146097) >> 2) << 2) + 3
      Y = (i \ 146097) * 100 + (j \ 1461)
      i = (((j mod 1461) + 4 ) >> 2) * 5 - 3
      M = i \ 153
      D = (((i mod 153) + 5 ) \ 5)
      If M < 10
         Inc M,3
      Else
         Dec M,9
         Inc Y
      EndIf
      Inc Y,1600
   Else
      D = N + 1
      M = 1
      Y = 1600
      If D > 31
         Dec D,31
         Inc M
      EndIf
   EndIf
   Case pY : Long pY,0 = Y
   Case pM : Long pM,0 = M
   Case pD : Long pD,0 = D
   Return dt("SetDate",Y,M,D)
EndProc




/*
WeekdayStep:
   Der erste Teil des Modus-Strings enthält:                    First,Prev,Next,Last
   Der zweite Teil ist der gewünschte Wochentag als Abkürzung:  Mo,Di,Mi,Do,Fr,Sa,So, Mo,Tu,We,Th,Fr,Sa,Su
*/
/* WeekdayStep: Wochentage durchlaufen */
/*   modus: - FirstMo  - PrevDi  - NextDo  - LastSa */
SubProc dt.WeekdayStep
   Parameters float D, string Modus

   Declare int Mode, WD, W, string WDay
   Modus = Lower$(Modus)  :  WDay = Right$(Modus,2)  :  WD = 1
   Case InStr("first",Modus) : Mode = 0
   Case InStr("prev",Modus) : Mode = 1
   Case InStr("next",Modus) : Mode = 2
   Case InStr("last",Modus) : Mode = 3
   WhileLoop 1,14
      If SubStr$("mo,di,mi,do,fr,sa,so,mo,tu,we,th,fr,sa,su", &Loop, ",") = WDay
         Case &Loop <= 7 : WD = &Loop - 1
         Case &Loop  > 7 : WD = &Loop - 8
         BREAK
      EndIf
   EndWhile
   
   // Korrektur des Tages
   Case Mode = 0 : D = dt("BoM",D)   // First
   Case Mode = 3 : D = dt("EoM",D)   // Last
  
   While WD < 0 : Inc WD,7 : EndWhile : WD = WD mod 7 : Inc WD
   W = dt("getDoW",D!)
   Select Mode
     CaseOf 0  // First
       While W <> WD
         D = D + 1
         Inc W
         Case W > 7 : W = 1
       EndWhile
     CaseOf 1  // Prev
       Repeat
         D = D - 1
         Dec W
         Case W < 1 : W = 7
       Until W = WD
     CaseOf 2  // Next
       Repeat
         D = D + 1
         Inc W
         Case W > 7 : W = 1
       Until W = WD
     CaseOf 3  // Last
       While W <> WD
         D = D - 1
         Dec W
         Case W < 1 : W = 7
       EndWhile
   EndSelect
   Return D
EndProc

/* nur zur Vereinfachung mit aufgenommen */
SubProc dt.FirstMo  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstMo")  :  EndProc
SubProc dt.FirstDi  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstDi")  :  EndProc
SubProc dt.FirstMi  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstMi")  :  EndProc
SubProc dt.FirstDo  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstDo")  :  EndProc
SubProc dt.FirstFr  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstFr")  :  EndProc
SubProc dt.FirstSa  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstSa")  :  EndProc
SubProc dt.FirstSo  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstSo")  :  EndProc
SubProc dt.FirstTu  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstTu")  :  EndProc
SubProc dt.FirstWe  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstWe")  :  EndProc
SubProc dt.FirstTh  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstTh")  :  EndProc
SubProc dt.FirstSu  :  Parameters float D  :  Return dt("WeekdayStep",D,"FirstSu")  :  EndProc

SubProc dt.PrevMo  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevMo")  :  EndProc
SubProc dt.PrevDi  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevDi")  :  EndProc
SubProc dt.PrevMi  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevMi")  :  EndProc
SubProc dt.PrevDo  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevDo")  :  EndProc
SubProc dt.PrevFr  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevFr")  :  EndProc
SubProc dt.PrevSa  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevSa")  :  EndProc
SubProc dt.PrevSo  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevSo")  :  EndProc
SubProc dt.PrevTu  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevTu")  :  EndProc
SubProc dt.PrevWe  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevWe")  :  EndProc
SubProc dt.PrevTh  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevTh")  :  EndProc
SubProc dt.PrevSu  :  Parameters float D  :  Return dt("WeekdayStep",D,"PrevSu")  :  EndProc

SubProc dt.NextMo  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextMo")  :  EndProc
SubProc dt.NextDi  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextDi")  :  EndProc
SubProc dt.NextMi  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextMi")  :  EndProc
SubProc dt.NextDo  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextDo")  :  EndProc
SubProc dt.NextFr  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextFr")  :  EndProc
SubProc dt.NextSa  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextSa")  :  EndProc
SubProc dt.NextSo  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextSo")  :  EndProc
SubProc dt.NextTu  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextTu")  :  EndProc
SubProc dt.NextWe  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextWe")  :  EndProc
SubProc dt.NextTh  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextTh")  :  EndProc
SubProc dt.NextSu  :  Parameters float D  :  Return dt("WeekdayStep",D,"NextSu")  :  EndProc

SubProc dt.LastMo  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastMo")  :  EndProc
SubProc dt.LastDi  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastDi")  :  EndProc
SubProc dt.LastMi  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastMi")  :  EndProc
SubProc dt.LastDo  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastDo")  :  EndProc
SubProc dt.LastFr  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastFr")  :  EndProc
SubProc dt.LastSa  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastSa")  :  EndProc
SubProc dt.LastSo  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastSo")  :  EndProc
SubProc dt.LastTu  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastTu")  :  EndProc
SubProc dt.LastWe  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastWe")  :  EndProc
SubProc dt.LastTh  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastTh")  :  EndProc
SubProc dt.LastSu  :  Parameters float D  :  Return dt("WeekdayStep",D,"LastSu")  :  EndProc


/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Proc Kalender
   Parameters int Y
   Declare int DoY, float dd, LastDat, xmas, adv4, ea, septua, trini_stop, string Kalenderdatei, xx
   adv4 = dt("Advent4",Y) : trini_stop = adv4 - 35  // Ende der Trinitatis-Sonntage (Woche vor Volkstrauertag)
   ea   = dt("Easter",Y)  : septua     = ea   - 63  // Ende der Epiphanias-Sonntage (Woche vor Septuagesimä)
   
   Proc Fix
      Parameters int d,m,y, string s
      declare int DoY
      LastDat = dt("setDate",y,m,d)
      doy = dt("getDoY",LastDat) + 1000
      AddString(0,str$(doy) $ " | " $ dt("DateTimeStr","dd.mm.yyyy (ddd) | ",LastDat) $ s)
   EndProc
   Proc Vari
      Parameters float da, string s
      declare int DoY
      LastDat = da
      doy = dt("getDoY",LastDat) + 1000
      AddString(0,str$(doy) $ " | " $ dt("DateTimeStr","dd.mm.yyyy (ddd) | ",LastDat) $ s)
   EndProc
   
   ClearList 0
   fix( 1, 1,Y,"Neujahr [F]")
      dd = dt("NextSo",LastDat) : Case dt("getDoY",dd) < 6 : vari(dd,"So. n. Neujahr")
   fix( 6, 1,Y,"Hl. 3 Könige (Epiphanias) [f;BW,BY,ST]")
      dd = dt("NextSo",LastDat)
      WhileLoop 1,6 : Case dd < septua : vari(dd, &Loop $ ". So. n. Epiphanias") : dd = dt("NextSo",dd) : EndWhile
   fix( 2, 2,Y,"Mariä Lichtmeß")
   fix(14, 2,Y,"Valentinstag")
   fix(25, 3,Y,"Mariä Verkündigung")
   fix(30, 4,Y,"Walpurgisnacht")
   fix(24, 6,Y,"Johannistag")
   fix(27, 6,Y,"Siebenschläfer")
   fix(29, 6,Y,"Peter und Paul")
   fix(15, 8,Y,"Mariä Himmelfahrt [f;BY,SL]")
   fix(24, 8,Y,"Bartholomäustag")
   fix( 1, 9,Y,"Ägidii")
   fix( 8, 9,Y,"Mariä Geburt")
   fix(29, 9,Y,"Michaelis")

   ' Im Jahr 2017, dem 500. Jahr des Beginns der Reformation, 
   ' ist der 31. Oktober einmalig ein gesamtdeutscher
   ' gesetzlicher Feiertag.
   if (Y = 2017) 
      fix(31,10,Y,"Reformationstag [F]")
   Else
      fix(31,10,Y,"Reformationstag [f;BB,MV,SN,ST,TH]")
   EndIf
   fix(31,10,Y,"Halloween")
   fix( 1,11,Y,"Allerheiligen [f;BW,BY,NW,RP,SL]")
   fix( 2,11,Y,"Allerseelen")
   fix(11,11,Y,"Martinstag (Martini)")
   fix( 6,12,Y,"Nikolaus")
   fix( 8,12,Y,"Mariä Empfängnis")
   fix(26,12,Y,"2. Weihnachtsfeiertag [F]")
   fix(31,12,Y,"Silvester")
   
   // Jahreszeiten
   fix(21, 3,Y,"Frühlings-Tagundnachtgleiche")
   fix(21, 6,Y,"Sommer-Sonnenwende")
   fix(22, 9,Y,"Herbst-Tagundnachtgleiche")
   fix(21,12,Y,"Winter-Sonnenwende")
   
   // Sternzeichen
   fix(21, 1,Y,"Sternzeichen Wassermann")
   fix(20, 2,Y,"Sternzeichen Fische")
   fix(21, 3,Y,"Sternzeichen Widder")
   fix(21, 4,Y,"Sternzeichen Stier")
   fix(21, 5,Y,"Sternzeichen Zwillinge")
   fix(22, 6,Y,"Sternzeichen Krebs")
   fix(23, 7,Y,"Sternzeichen Löwe")
   fix(24, 8,Y,"Sternzeichen Jungfrau")
   fix(24, 9,Y,"Sternzeichen Waage")
   fix(24,10,Y,"Sternzeichen Skorpion")
   fix(23,11,Y,"Sternzeichen Schütze")
   fix(22,12,Y,"Sternzeichen Steinbock")
   
   Case Y >= 1934 : fix( 1, 5,Y,"Maifeiertag [F]")
   Case Y >= 1964 : fix( 5, 5,Y,"Europatag (Gründung des Europarates 1949)")
   Case Y >= 1985 : fix( 9, 5,Y,"Europatag (Schuman-Erklärung (1950), mündete in EGKS u später EU)")
   If Between(Y,1954,1990)
      fix(17, 6,Y,"Tag der deutschen Einheit [F]")
   ElseIf Y >= 1991
      fix(17, 6,Y,"Tag der deutschen Einheit [Gedenktag]")
   EndIf
   Case Y >= 1990 : fix( 3,10,Y,"Tag der Deutschen Einheit [F]")

   // Sommerzeit
   vari( dt("LastSo",dt("setDate",Y, 3,1)), "Anfang der Sommerzeit (MESZ)")  // letzter SO im März
   vari( dt("LastSo",dt("setDate",Y,10,1)), "Ende der Sommerzeit (Normalzeit) (MEZ)")  // letzter SO im Oktober
   
   // Muttertag
   Case Y >= 1933 : vari( dt("FirstSo",dt("setDate",Y,5,1)) + 7, "Muttertag")  // zweiter SO im Mai (Trick: erster SO + 7)

   // Erntedank rk & ev
   Case Y >= 1972 : vari( dt("FirstSo",dt("setDate",Y,9,1)), "Erntedankfest (1. SO i Sept) [rk]")
   Case Y >= 1770 : vari( dt("NextSo",dt("setDate",Y,9,29)), "Erntedankfest (SO n Michaelis) [ev]")

   // Trinitatis-Sonntage (1..27)
   If Y >= 1334
      dd = ea + 56 + 7
      WhileLoop 1,27
         Case dd < trini_stop : vari(dd, &Loop $ ". So. n. Trinitatis")
         dd = dd + 7
      EndWhile
   EndIf


   // Advent
'  adv4 = dt("Advent4",Y)
   fix(25,12,Y,"1. Weihnachtsfeiertag [F]")
      xmas = LastDat
      If (LastDat - 1) = adv4
         fix(24,12,Y,"4. Advent und Heiligabend")
      Else
         fix(24,12,Y,"Heiligabend")
         vari(adv4,"4. Advent")
      EndIf
      Case dt("getDoW",xmas) <= 5 : vari(dt("NextSo",xmas),"So. n. Weihnachten")
   vari(adv4 - 7 ,"3. Advent")
   vari(adv4 - 14,"2. Advent")
   vari(adv4 - 21,"1. Advent")
   vari(adv4 - 28,"Totensonntag (Ewigkeitssonntag) [G]")
   vari(adv4 - 28,"Christkönigsfest [rk]")
   If Between(Y,1934,1938)
      vari(adv4 - 32,"Buß- und Bettag [F]")
   ElseIf Between(Y,1946,1951)
      vari(adv4 - 32,"Buß- und Bettag [f;BE,BW,HB,HE,HH,NI,NW,RP,SH,SL]")
   ElseIf Between(Y,1952,1980)
      vari(adv4 - 32,"Buß- und Bettag [f;BE,BW,BY(ev),HB,HE,HH,NI,NW,RP,SH,SL]")
   ElseIf Between(Y,1981,1989)
      vari(adv4 - 32,"Buß- und Bettag [f;BE,BW,BY,HB,HE,HH,NI,NW,RP,SH,SL]")
   ElseIf Between(Y,1990,1994)
      vari(adv4 - 32,"Buß- und Bettag [F;BE,BW,BY,HB,HE,HH,NI,NW,RP,SH,SL,BB,MV,SN,ST,TH]")
   ElseIf Y >= 1995
      vari(adv4 - 32,"Buß- und Bettag [f;SN]")
   EndIf
   vari(adv4 - 35,"Volkstrauertag")
   vari(adv4 - 42,"Drittletzter SO des Kirchenjahres")


   // Ostern
'  ea = dt("Easter",Y)
   vari(ea - 52,"Weiberfastnacht (Schmotziger DO) (-Karneval-)")
   vari(ea - 51,"Rußiger Freitag (-Karneval-)")
   vari(ea - 50,"Nelkensamstag (Schmalziger SA) (-Karneval-)")
   vari(ea - 49,"Tulpensonntag (Herrenfastnacht) (-Karneval-)")
   vari(ea - 48,"Rosenmontag (-Karneval-)")
   vari(ea - 47,"Fastnacht (Veilchendienstag) (-Karneval-)")
   vari(ea - 46,"Aschermittwoch (Beginn der Fastenzeit) (-Karneval-)")
   
   vari(ea - 63,"Septuagesimae (9.So v Ostern)")
   vari(ea - 56,"Sexagesimae (8.So v Ostern)")
   vari(ea - 49,"Estomihi (7.So v Ostern)")
   vari(ea - 42,"Invokavit (6.FastenSo v Ostern)")
   vari(ea - 35,"Reminiscere (5.FastenSo v Ostern)")
   vari(ea - 28,"Okuli (4.FastenSo v Ostern)")
   vari(ea - 21,"Laetare (3.FastenSo v Ostern)")
   vari(ea - 14,"Judica (2.FastenSo v Ostern)")
   vari(ea -  8,"[en] (Sat. of Lazarus)")
   vari(ea -  7,"Palmsonntag (1.FastenSo v Ostern)")
   vari(ea -  3,"Gründonnerstag")
   vari(ea -  2,"Karfreitag [F]")
   vari(ea -  1,"Karsamstag (Ostersamstag)")
   vari(ea     ,"Ostersonntag (rk:1.So der Osterzeit) [f;BB]")
   vari(ea +  1,"Ostermontag [F]")
   vari(ea +  7,"Quasimodogeniti (ev:1.So n Ostern)(rk:2.So der Osterzeit/Weißer Sonntag)")
   vari(ea + 14,"Misericordias Domini (ev:2.So n Ostern)(rk:3.So der Osterzeit)")
   vari(ea + 21,"Jubilate (ev:3.So n Ostern)(rk:4.So der Osterzeit)")
   vari(ea + 28,"Kantate (ev:4.So n Ostern)(rk:5.So der Osterzeit)")
   vari(ea + 35,"Rogate (ev:5.So n Ostern)(rk:6.So der Osterzeit)")
   vari(ea + 39,"Christi Himmelfahrt (Vatertag/Herrentag) [F]")
   vari(ea + 42,"Exaudi (ev:6.So n Ostern)(rk:7.So der Osterzeit)")
   vari(ea + 49,"Pfingstsonntag (7.So n Ostern) [f;BB]")
   vari(ea + 50,"Pfingstmontag [F]")
   vari(ea + 53,"Fronleichnam (Corpus Domini, Corpus Christi) [f;BW,BY,HE,NW,RP,SL]")

   Case Y >= 1856 : vari(ea + 63,"Herz Jesu Fest (2. SO n Pfingsten)")
   Case Y >= 1334 : vari(ea + 56,"Trinitatis (8. So n Ostern; 1. SO n Pfingsten) Dreifaltigkeit/Dreieinigkeit")

   
   SortList 1

   ' Kalenderdatei
   Declare int err
   MkDir "C:\TEMP"
   err = %IOResult
   Kalenderdatei = "C:\TEMP\KALENDER_" $ Y $ "_TEMP.txt"
   Move("ListToFile",Kalenderdatei)
   ClearList
   Shell "NotePad " $ Kalenderdatei
EndProc


Proc Test
   Declare d1!,d2!,d!,Y%, e%

   Proc Zeige
      Parameters float d, string s
      Print dt("DateTimeStr", "   ddd', der 'dd. mmmm yyyy; (", d ) $ dt("getDoW",d) $ "); " $ s
   EndProc

   Proc Zeige2
      Parameters float d1,d2, string s
      Print dt("DateTimeStr", "  dd.mm.yyyy (ddd)(", d1 ) $ dt("getDoW",d1) $ "); " $ s $ dt("DateTimeStr", "  dd.mm.yyyy (ddd)(", d2 ) $ dt("getDoW",d2) $ "); "
   EndProc

   Cls
   d2! = !now
   Y% = dt("GetYear",d2!)
   Print "Advent4"
    d1! = dt("Advent4",Y%)
    Zeige(d1!, "4. Advent")
    Zeige(d1! - 7, "3. Advent")
    Zeige(d1! - 14, "2. Advent")
    Zeige(d1! - 21, "1. Advent")
    Zeige(d1! - 28, "Totensonntag")
    Zeige(d1! - 32, "Buß- und Bettag")
    Zeige(d1! - 35, "Volkstrauertag")
   Print "BoW - Beginning Of Week"
    Zeige2( dt("BoW",d1!), dt("EoW",d1!), "(BoW)")
   Print "BoM/EoM - Beginning/End Of Month"
    Zeige2( dt("BoM",d1!), dt("EoM",d1!), "(BoM)")
   Print "BoQ - Beginning Of Quarter"
    Zeige2( dt("BoQ",d1!), dt("EoQ",d1!), "(BoQ)")
    whileloop 1,4
     Zeige2( dt("BoQ",2016,&loop), dt("EoQ",2016,&loop), "(BoQ) " $ &loop $ ".Q.")
    endwhile
   Print "BoY - Beginning Of Year"
    Zeige2( dt("BoY",d1!), dt("EoY",d1!), "(BoY)")
   Print "Ostern"
    d1! = dt("Easter",Y%)
    Zeige(d1!, "Ostersonntag")
    Zeige(dt("bow",d1!), "Mo")
    Zeige(dt("eow",d1!), "So")
    
'    d2! = dt("FirstSo",d1!)
'    whileloop 1,4
'     Zeige(d2!, &loop $ ". So")
'     d2! = dt("NextSo",d2!)
'    endwhile
'WaitInput
   Print "LastDayInMonth"
    Print "   ";dt("LastDayInMonth",1,2017);
    WhileLoop 2,12
       Print ", ";dt("LastDayInMonth",&loop,2017);
    EndWhile
    Print ""
WaitInput


   If dt("Quarter",!now) <= 2
     ' Vorjahr und aktuelles Jahr
     Kalender( dt("getYear",!now) - 1 )
     Kalender( dt("getYear",!now) )
   Else
     ' aktuelles Jahr und nächstes Jahr
     Kalender( dt("getYear",!now) )
     Kalender( dt("getYear",!now) + 1 )
   EndIf

   WaitInput
EndProc

Proc Test2
   Declare float d1,d2, long n1, D,M,Y, string s1
   
   Proc Zeige
      Parameters float d, string s
      Print dt("DateTimeStr", "   ddd', der 'dd. mmmm yyyy; (", d )   $   dt("getDoW",d)   $   "); "   $   s
   EndProc

   Proc Zeige2
      Parameters float d1,d2, string s
      Print dt("DateTimeStr", "  dd.mm.yyyy (ddd)(", d1 ) $ dt("getDoW",d1) $ dt("getDoW_Str",d1,1,"de") $ "); " $   s$   $ dt("DateTimeStr", "  dd.mm.yyyy (ddd)(", d2 ) $ dt("getDoW",d2)  $ dt("getDoW_Str",d2,1,"de") $ "); "
   EndProc
   
   d2 = !now
   Zeige( d2, "(!now)")
   d1 = dt("Advent4",d2)
   Zeige( d1,      "4. Advent")
   Zeige( d1 -  7, "3. Advent")
   Zeige( d1 - 14, "2. Advent")
   Zeige( d1 - 21, "1. Advent")
   Zeige( d1 - 28, "Totensonntag")
   Zeige( d1 - 32, "Buß- und Bettag")
   Zeige( d1 - 35, "Volkstrauertag")
   WhileLoop 1,12
      d1 = dt("setMonth",d1,&loop)
      Zeige2( dt("BoM",d1), dt("EoM",d1),"BOM/" $ dt("quarter",d1) $ "/EOM")
   EndWhile
waitinput
   Print ""
   d1 = dt("Easter",d2)
   Zeige( d1, "Ostern")
   Zeige2( dt("BoQ",d1), dt("EoQ",d1),"BOQ/" $ dt("quarter",d1) $ "/EOQ")
   WhileLoop 1,4
      d1 = dt("BoQ",2017,&loop)
      Zeige2( dt("BoQ",d1), dt("EoQ",d1),"BOQ/" $ dt("quarter",d1) $ "/EOQ")
   EndWhile
   d1 = !now
   Zeige2( dt("BoW",d1), dt("EoW",d1),"BOW/(now)/EOW")
   Zeige2( dt("BoY",d1), dt("EoY",d1),"BOY//EOY")
   Zeige( dt("dton",20171003), "DToC$('20171003')")
   Print "   und zurück..." $ dt("ntod",dt("dton",20171003))
   d2 = !now
   Zeige( d2, "(!now)")
   Print "   " $ dt("ActualDay") $ "." $ dt("ActualMonth") $ "." $ dt("ActualYear")
   d1 = !now
   Zeige( dt("dateadd",d1, 0,1,0,0), "1 woche")
   Zeige( dt("dateadd",d1, 0,-2,0,1), "-2 wo, 1 jahr")

   Zeige2( !now, !now + 70,"/70 Tage/")
   Print "   Unterschied: ", dt("DiffDate",!now, !now + 70, Addr(D),Addr(M),Addr(Y))
   Print "   Tage: ";D;", Monate: ";M;", Jahre: ";Y
waitinput
   Print ""
   d1 = !now
   WhileLoop 0,9
      s1 =      if(dt("isWorkday",d1),"Werktag","")
      s1 = s1 + if(dt("isWeekend",d1),"Wochenende","")
      Zeige( d1, s1)
      d1 = d1 + 1
   EndWhile
   d1 = dt("setDate",2017,8,18)
   Zeige( dt("PrevWorkday",d1), "vorheriger Werktag")
   Zeige( d1, "aktueller Tag")
   Zeige( dt("NextWorkday",d1), "folgender Werktag")

Print "\n   ...jetzt mit Änderung der Variablen"
dt_VAR_Beginning_of_the_Week = 7
dt_VAR_Weekend_Days_one_Week = 1
   d1 = !now
   WhileLoop 0,9
      s1 =      if(dt("isWorkday",d1),"Werktag","")
      s1 = s1 + if(dt("isWeekend",d1),"Wochenende","")
      Zeige( d1, s1)
      d1 = d1 + 1
   EndWhile
waitinput
   Print ""
   d1 = dt("setDate",2017,8,18)
   Zeige( dt("PrevWorkday",d1), "vorheriger Werktag")
   Zeige( d1, "aktueller Tag")
   Zeige( dt("NextWorkday",d1), "folgender Werktag")
   Print ""
   Zeige( dt("Yesterday"), "gestern (Yesterday)")
   Zeige( dt("Today"), "aktueller Tag (Today)")
   Zeige( dt("Tomorrow"), "morgen (Tomorrow)")

dt_VAR_Beginning_of_the_Week = 1
dt_VAR_Weekend_Days_one_Week = 2

   d1 = dt("setDate",2017,8,14,!now)
   d2 = dt("setDate",2017,8,27,!now)
   Print "   " $ dt("Sum_Workdays",d1,d2,addr(n1)) $ " Werktage und " $ n1 $ " Wochendtage."
   Print "\n\n\n\nEnde 2"

waitinput

EndProc


Test2
Test
end