Dies ist gcal.info, hergestellt von Makeinfo Version 4.0 aus gcal.texi.

INFO-DIR-SECTION GNU Pakete
START-INFO-DIR-ENTRY
* Gcal: (gcal).                        GNU Kalenderprogramm.
* Tcal: (gcal)Aufruf von tcal.         Gcal mit morgigem Datum aufrufen.
* Txt2gcal: (gcal)Aufruf von txt2gcal. Kalendertext zu Ressourcendatei wandeln.
* Gcal2txt: (gcal)Aufruf von gcal2txt. Kalenderressource zu Textdatei wandeln.
END-INFO-DIR-ENTRY

Diese Datei beschreibt Gcal, ein Programm um Kalender zu berechnen und
auszugeben.

Copyright (c) 1994-1997, 2000 Thomas Esken

Diese Ausgabe ist für Gcal Version 3.00.

Hiermit wird die Erlaubnis erteilt, wortgetreue Kopien dieses Handbuchs
zu erstellen und zu vertreiben, sofern alle gemachten Kopien mit dem
Copyrightvermerk und diesem Genehmigungsvermerk ausgestattet sind und
vorgenannte Vermerke erhalten bleiben.

Hiermit wird die Erlaubnis erteilt, veränderte Kopien dieses Handbuchs
wie unter den Bedingungen für wortgetreue Kopien zu erstellen und zu
vertreiben, sofern die ausgeführten Arbeiten in Ableitung und Gesamtheit
innerhalb der Bestimmungen eines Genehmigungsvermerks liegen und zudem
mit diesem ausgestattet sind, welcher mit diesem hier identisch ist.

Hiermit wird die Erlaubnis erteilt, wie unter den vorgenannten
Bedingungen für veränderte Versionen Übersetzungen dieses Handbuchs in
eine andere Sprache zu erstellen und zu vertreiben, mit der Ausnahme,
daß dieser Genehmigungsvermerk in einer Übersetzung angegeben sein
darf, welche von der Free Software Foundation gebilligt wird.

Jedwede Vorschläge, Verbesserungen, Erweiterungen, Fehlerberichte, Geld-
und Sachspenden, Programmieraufträge usw. sind stets willkommen.  Bitte
senden Sie diese direkt an meine eMail Adresse <esken@gmx.net>.  Wenn
Sie dieses Werkzeug mögen, so würde ich mich sehr über eine Postkarte
von Ihnen freuen!

------------------------oOO      \\\_''/      OOo---------------------------
Thomas Esken               O     (/o-o\)     O  eMail: esken@gmx.net
Im Hagenfeld 84                 ((  ^  ))       Phone: +49 251 232585
D-48147 Muenster; Germany    \____) ~ (____/    MotD : 2old2live, 2young2die


File: gcal.info,  Node: Datumvariablen,  Next: Textvariablen,  Prev: Einfuegeanweisungen,  Up: Ressourcendatei

Datumvariablen
--------------

Gcal berücksichtigt _globale_ und/oder _lokale_ Datumvariablen, die
entweder im Datumteil einer Zeile der Gcal Ressourcendatei oder als
Bestandteil eines Spezialtexts im Textteil einer Zeile der
Ressourcendatei verwendet werden dürfen.  Das bedeutet, daß bis zu *24*
benutzerdefinierte Datumvariablen gesetzt und während der
Programmausführung referenziert werden können.  *Note Termin Option
`--date-variable=ARGUMENT': x-date-variable, für weitere Details zu
globalen Datumvariablen.

Der Name einer Datumvariablen DVAR besteht aus einem einzelnen
Buchstaben(1) (*note Datumvariablen-Footnote-1::).  In einer Definition
folgt diesem Namen sodann der Zuweisungsoperator `=', und die
Zahlenwerte für Monat MM (oder einem Monatsnamen im 3-Buchstaben
Kurzformat, z.B. `Jan', `Feb', ...) und Tag TT, welche diese Variable
aufzunehmen hat(2) (*note Datumvariablen-Footnote-2::), z.B.:

     a=1127
     c=a

speichert den 27'ten November in der lokalen Datumvariablen A und in
der lokalen Datumvariablen C.  Sie sollten stets in Erinnerung behalten,
daß Datumvariablen erst dann in einer Zeile referenziert werden können,
wenn diese bereits definiert worden sind, da eine Ressourcendatei von
Gcal Zeile für Zeile abgearbeitet wird.

Nur an lokale Datumvariablen können dynamische Daten zugewiesen werden,
die im `MMWWWN', `DVAR[+|-]N[WWW]' oder `*d|wN[WWW]' Format angegeben
sind, z.B.:

     a=03so2
     b=JunMon9
     c=b-3
     d=c+4Sa
     x=*d10
     y=*d10fre
     z=*w3So

Vorstehendes bedeutet, daß die Datumvariable A das Datum des 2'ten
Sonntags im März speichert und B das Datum des letzten Montags im Monat
Juni speichert.  Datumvariable C speichert das Datum, welches drei Tage
vor dem Datum des letzten Montags im Juni liegt und in der
Datumvariablen D wird dieses Datum auf dasjenige Datum gesetzt, welches
sich vier Samstage nach dem Datum von C ergibt.  Datumvariable X
speichert das Datum des 10'ten absoluten Tages des Jahres (== 10'ter
Januar).  Y speichert das Datum des 10'ten Freitags des Jahres, und Z
wird das Datum des Sonntags, der in die 3'te Kalenderwoche fällt,
zugewiesen.

*Achtung:*
Diese Art der Zuweisung an Datumvariablen wird *nur* innerhalb
einfacher Jahresgrenzen korrekt berechnet, also nicht in denjenigen
Terminen, welche ausgegeben werden, nachdem das laufende Jahr gewechselt
hat, z.B. in *Fiskaljahren*.

Datumvariablen, die in einer Ressourcendatei definiert werden, sind
stets lokal, und werden nur in dieser spezifischen Datei *und*
derjenigen Datei respektiert, welche in diese eingefügt wird.  Das
bedeutet hinsichtlich der eingefügten Datei, daß alle lokalen Variablen
der aufrufenden Datei sichtbar sind.  Die eingefügte Datei selbst darf
eigene lokale Variablen definieren, welche dann die bereits an anderer
Stelle definierten lokalen Variablen überdecken, und welche bei
Weiterverarbeitung der aufrufenden Datei nicht exportiert werden.  Alle
anderen Definitionen von Datumvariablen(3) (*note
Datumvariablen-Footnote-3::) sind stets global.  Falls eine Zeile einer
Ressourcendatei eine Referenz auf eine Datumvariable enthält, die nicht
lokal in dieser Datei definiert ist, so wird Gcal versuchen, die Werte
der entsprechenden globalen Variablen zu benutzen.  Sollte dieses nicht
gelingen, da keine globale Definition dieser Datumvariablen vorliegt,
so wird Gcal diese Zeile nicht verarbeiten.  Wenn zudem die einfache
`--debug' bzw. `--debug=internal' Option angegeben wurde, so wird ein
Informationstext auf dem _Standardfehler-Gerätekanal_ für jede
undefinierte Datumvariable ausgegeben (*note Globale Option
`--debug=internal': x-debug-internal.).  Falls die `--debug=abort'
Option angegeben wurde und eine Referenz einer undefinierten
Datumvariable auftrat, so wird das Gcal Programm mit Fehlerkode
abgebrochen.  *Note Fehlerkode 113: x-113-Fehlerkode, und *Note Globale
Option `--debug=abort': x-debug-abort, für weitere Informationen.

Eine lokale Datumvariable kann aber auch gelöscht werden, was bedeutet,
daß diese Datumvariable keinen lokalen Gültigkeitsbereich mehr aufweist
und somit undefiniert ist.  So ist es dann möglich, daß in einer
Folgezeile, in der diese Datumvariable referenziert wird, ein
möglicherweise global gesetzter Wert dieser Datumvariable verwendet
werden kann.  Das nachfolgende Beispiel der Ressourcendatei `dvar-1.rc'
verdeutlicht diesen Sachverhalt:

     $ cat dvar-1.rc
     -| ; dvar-1.rc
     -| ;
     -| z=0202
     -| 0@z Das lokal an `z' zugewiesene Datum
     -| z=
     -| 0@z Das global an `z' zugewiesene Datum
     -| z=0404
     -| 0@z Das lokal an `z' zugewiesene Datum

So erzeugt Gcal die folgenden Ausgaben:

     $ gcal %1777 -H no -x -v z=1212 -f ./dvar-1.rc -y
     -|
     -| So,   2 Feb 1777: Das lokal an `z' zugewiesene Datum
     -| Fr,   4 Apr 1777: Das lokal an `z' zugewiesene Datum
     -| Fr,  12 Dez 1777: Das global an `z' zugewiesene Datum
     $ gcal %1777 -H no -x -f ./dvar-1.rc -y
     -|
     -| So,   2 Feb 1777: Das lokal an `z' zugewiesene Datum
     -| Fr,   4 Apr 1777: Das lokal an `z' zugewiesene Datum

Nur fortgeschrittene Benutzer sollten die `--export-date-variables'
Option benutzen, welche bewirkt, daß die aktuelle Inkarnation einer
lokalen Datumvariablen --welche zuvor in einer Ressourcendatei
definiert wurde und nicht in einer eingefügten Datei-- an weitere
Ressourcendateien exportiert wird, anstelle der Benutzung deren
globalen Wertes, falls diese Datumvariable nicht lokal in dieser
weiteren Ressourcendatei definiert ist.  *Note Einfügeanweisungen:
Einfuegeanweisungen, für weitere Details.

Aber seien Sie vorsichtig, die Benutzung dieser Option könnte
unerwartete Ergebnisse erzeugen, da die Reihenfolge der Abarbeitung der
Ressourcendateien eine wichtige Größe hinsichtlich der Wirkung der
`--export-date-variables' Option ist, so daß es nicht empfohlen werden
kann, diese Option zu benutzen.  Sie, der Benutzer, müssen sehr genau
wissen, was Sie mit dieser Option bezwecken wollen; *Sie seien nun
ausdrücklich gewarnt!*

Einige grundlegende Operationen können auf Datumvariablen ausgeführt
werden.  Diese sind:

*Operation*    *Beschreibung*

`DVAR++'       Einfache Inkrementierung um einen Tag.
`DVAR--'       Einfache Dekrementierung um einen Tag.
`DVAR+=[+|-]N' Addition eines konstanten numerischen Tagesfaktors [+|-]N.
`DVAR-=[+|-]N' Subtraktion eines konstanten numerischen Tagesfaktors
               [+|-]N.
`DVAR+=NWWW'   Addition von N Wochentagen WWW.
`DVAR-=NWWW'   Subtraktion von N Wochentagen WWW.

Der Gültigkeitsbereich der Operationen, welche auf einer lokalen
Datumvariablen durchgeführt werden, erstreckt sich auf die
Ressourcendatei oder die eingefügte Datei, in welcher die lokale
Datumvariable definiert wurde.

Falls Operationen auf eine globale Datumvariable in einer
Ressourcendatei oder in derjenigen Datei, die in diese eingefügt wird,
durchgeführt werden, so sind diese Operationen nur in dieser
entsprechenden Datei gültig(4) (*note Datumvariablen-Footnote-4::),
nicht aber in weiteren Ressourcendateien, welche verarbeitet werden.
Das bedeutet, daß die Initialwerte der globalen Datumvariablen stets
restauriert werden, falls die zu verarbeitende Ressourcendatei wechselt.

Bitte beachten Sie abschließend, daß jede Zuweisung an eine
Datumvariable oder Operation auf eine Datumvariable in einer separaten
Zeile der Ressourcendatei erfolgen muß.


File: gcal.info,  Node: Datumvariablen-Footnotes,  Up: Datumvariablen

(1) Groß- bzw. Kleinbuchstaben werden nicht unterschieden.  Nicht
zuweisbar bzw. inoperabel ist die Datumvariable E, welche intern für
das Datum des Ostersonntags reserviert ist.  Ebenfalls nicht zuweisbar
bzw. inoperabel ist die Datumvariable T, welche intern für das heutige
Datum reserviert ist.

(2) Oder dem Namen einer anderen, bereits definierten, Datumvariablen.

(3) In der Kommandozeile, Umgebungsvariable `GCAL' oder Antwortdatei.

(4) Diese werden nur lokal ausgeführt.


File: gcal.info,  Node: Textvariablen,  Prev: Datumvariablen,  Up: Ressourcendatei

Textvariablen
-------------

Gcal berücksichtigt _globale_ und/oder _lokale_ Textvariablen, die
überall in einer Zeile der Gcal Ressourcendatei verwendet werden
dürfen.  Das bedeutet, daß bis zu *26* benutzerdefinierte Textvariablen
gesetzt und während der Programmausführung referenziert werden können.
*Note Termin Option `--text-variable=ARGUMENT': x-text-variable, für
weitere Details zu globalen Textvariablen.

Der Name einer Textvariablen TVAR besteht aus einem `$' Präfix und
einem einzelnen Buchstaben(1) (*note Textvariablen-Footnote-1::).

Eine Textvariable wird wie folgt definiert:

   * Wird der Name der Textvariablen von einem `=' Zuweisungsoperator
     gefolgt, so wird der gesamte Text, der rechts von diesem
     Zuweisungsoperator auftritt, an diese Textvariable zugewiesen.

   * Wird der Name der Textvariablen von einem `?' Zuweisungsoperator
     gefolgt, so wird der gesamte Text, der rechts von diesem
     Zuweisungsoperator auftritt, von Gcal als externes Kommando
     aufgefasst und ausgeführt.  Die Ausgabe, die das Kommando auf dem
     _Standardausgabe-Gerätekanal_ erzeugt hat, wird an diese
     Textvariable zugewiesen; und zwar interpretiert.  Das heißt, Gcal
     interpretiert alle in dieser Ausgabe enthaltenen Spezialtexte und
     Textvariablenreferenzen.  *Note Spezialtexte::, für weitere
     Informationen.

   * Wird der Name der Textvariablen von einem `:' Zuweisungsoperator
     gefolgt, so wird der gesamte Text, der rechts von diesem
     Zuweisungsoperator auftritt, von Gcal als externes Kommando
     aufgefasst und ausgeführt.  Die Ausgabe, die das Kommando auf dem
     _Standardausgabe-Gerätekanal_ erzeugt hat, wird an diese
     Textvariable zugewiesen; und zwar uninterpretiert.  Das heißt,
     Gcal interpretiert keine in dieser Ausgabe enthaltenen
     Spezialtexte und Textvariablenreferenzen.  Siehe ebenfalls *Note
     Spezialtexte::, für weitere Details.

Allerdings werden externe Kommandos von Gcal nur dann ausgeführt, wenn
die `--execute-command' Option beim Programmaufruf angegeben wurde.
*Note Termin Option `--execute-command': x-execute-command, für weitere
Informationen.

Der Text, der rechts von einem der zulässigen Zuweisungsoperatoren
auftritt, darf Namen von bereits definierten Textvariablen
referenzieren.  Bevor die Zuweisung vorgenommen wird, werden diese
Referenzen dann von Gcal in ihre entsprechenden textlichen Ausprägungen
umgesetzt.  Sie sollten stets in Erinnerung behalten, daß Textvariablen
erst dann in einer Zeile referenziert werden können, wenn diese bereits
definiert worden sind, da eine Ressourcendatei von Gcal Zeile für Zeile
abgearbeitet wird.  Textvariablenreferenzen werden von Gcal stets
solange rekursiv expandiert, bis alle Sub-Referenzen auf andere
Textvariablen aufgelöst sind.

Lokale Textvariablen werden auf einen _leeren Wert_ gesetzt und dabei
gleichzeitig in einem Sondermodus definiert, falls kein Text rechts von
einem der zulässigen Zuweisungsoperatoren angegeben ist.

Wird eine Textvariable referenziert, so darf zwischen dem `$' Präfix
und dem einzelnen Buchstaben (hier: der Variablenname) noch eine
optionale Formatanweisung angegeben werden, die es ermöglicht, den Text
(hier: den Inhalt), auf den die Textvariable verweist, besonders
darzustellen.  Angenommen, es existiert eine Ressourcendatei mit dem
Namen `tvarf-1.rc' und dem folgenden Inhalt:

     $ cat tvarf-1.rc
     -| ; tvarf-1.rc
     -| ;
     -| $a=123
     -| $b=$:010*a
     -| $c=$b
     -| $b=
     -| 0 1. \$c=.$c.
     -| 0 2. \$c=.$:20*c.
     -| 0 3. \$b=.$>1w*b.
     -| 0 4. \$a=.$>5#a.

So erzeugt Gcal die folgende Ausgabe:

     $ gcal -Ux --text-variable='$b=XXX YY' --resource-file=./tvarf-1.rc
     -|
     -| 1. $c=.0000000123.
     -| 2. $c=.      0000000123       .
     -| 3. $b=.Xxx Yy.
     -| 4. $a=.  123.

*Note Formatanweisung::, für die ausführliche Beschreibung der
Formatanweisung und ihrer Komponenten.

Falls das `$' Zeichen im Text als Zeichen selbst verwendet werden soll,
so muß dieses durch ein führendes `\' (Backslash) Zeichen hinsichtlich
seiner speziellen Bedeutung entwertet werden, z.B. `\$'.  Wenn die
Zeichen `\$' im Text selbst als Zeichenfolge verwendet werden sollen,
so muß das `\' (Backslash) Zeichen durch ein weiteres `\' (Backslash)
Zeichen geschützt werden, z.B. `\\$'.

Externe Kommandos werden nicht direkt von Gcal ausgeführt, sondern von
dem Kommandointerpretierer des Betriebssystems, der shell.  Das hat zur
Folge, daß die Kommandos natürlich entsprechend den Syntaxkonventionen
im Hinblick auf die Gruppierungsregeln, Listenverarbeitungsregeln,
Umlenkungsregeln et cetera der verwendeten shell angegeben sein müssen!
Zum Beispiel kann es sein, daß `$a?(cat text)' anstelle des einfachen
`$a?cat text' geschrieben werden muß.  Für weitere Einzelheiten hierzu
sei auf die einschlägige Fachliteratur verwiesen.

Bei der interpretierten Zuweisung der Ausgabe von externen Kommandos an
Textvariablen, die auf dem _Standardausgabe-Gerätekanal_ erscheint,
wird die Ausgabe von Gcal intern in eine temporäre Datei umgelenkt.
Danach wird der Inhalt der temporären Datei an die Textvariable
übertragen, und die temporäre Datei wird entfernt.

Bei der uninterpretierten Zuweisung der Ausgabe von externen Kommandos
an Textvariablen, die auf dem _Standardausgabe-Gerätekanal_ erscheint,
wird die Ausgabe zuerst intern vom Txt2gcal Programm bearbeitet (*note
Aufruf von `txt2gcal': Aufruf von txt2gcal.), und erst dann wird die
Ausgabe von Gcal intern in eine temporäre Datei umgelenkt.  Danach wird
der Inhalt der temporären Datei an die Textvariable übertragen, und die
temporäre Datei wird entfernt.  Falls eine `TXT2GCALPROG'
Umgebungsvariable (*note Umgebungsvariable `TXT2GCALPROG':
x-TXT2GCALPROG.)  definiert und mit dem Dateinamen des ausführbaren
Txt2gcal Programms gesetzt ist, so benutzt Gcal diesen Dateinamen, um
Txt2gcal aufzurufen.  Andernfalls benutzt Gcal den beim
Kompilationsvorgang eingebrannten Dateinamen `txt2gcal', um das
Txt2gcal Programm aufzurufen.  Die `TXT2GCALPROG' Umgebungsvariable muß
immer dann gesetzt werden, wenn das Txt2gcal Programm unter einem
anderen Namen als dem Standardnamen `txt2gcal' installiert ist, da Gcal
sonst das Txt2gcal Programm nicht automatisch ausführen kann!

Wenn die einfache `--debug' bzw. `--debug=internal' Option bei
Programmstart angegeben wurde, so wird ein Text auf dem
_Standardfehler-Gerätekanal_ ausgegeben, der mit Informationen zum
ausgeführten Kommando und dessen _exit-Kode_ ausgestattet ist (*note
Globale Option `--debug=internal': x-debug-internal.).

Falls die `--debug=abort' Option angegeben wurde und sich ein
_exit-Kode_ ungleich Null bei der Ausführung des Kommandos ergab, so
wird das Gcal Programm mit Fehlerkode abgebrochen.  *Note Fehlerkode 2:
x-2-Fehlerkode, sowie *Note Globale Option `--debug=abort':
x-debug-abort, für weitere Informationen.

Nun folgt ein Beispiel, welches erläutert, wie die Ausgabe von externen
Kommandos an Textvariablen zugewiesen werden kann.  Angenommen, es
existiert eine Ressourcendatei mit dem Namen `tvarc-1.rc' und dem
folgenden Inhalt:

     $ cat tvarc-1.rc
     -| %t  $a $>+06*b $>1u*c

Diese Datei wird in der Ressourcendatei `tvarc-1a.rc' benutzt und von
Gcal wie folgt verarbeitet:

     $ cat tvarc-1a.rc
     -| ; tvarc-1a.rc
     -| ;
     -| $a=bonjour
     -| $b=123
     -| $c=bonsoir
     -| $x?cat $f
     -| 0 \$x=---$:30*x---
     -| $y:cat $f
     -| 0 \$y=---$y---
     -| 0 \$y=:::$>1u*y:::
     $ gcal -f tvarc-1a.rc -QUx --exe -r'$f=./tvarc-1.rc'
     -| $x=---    04:03 bonjour +00123 BONSOIR     ---
     -| $y=---%t  $a $>+06*b $>1u*c---
     -| $y=:::%T  $A $>+06*B $>1U*C:::

Nun folgen ein paar weitere Beispiele, wie Textvariablen von Gcal
verarbeitet werden.  Angenommen, es existiert eine Ressourcendatei mit
dem Namen `tvar-1.rc' und dem folgenden Inhalt:

     $ cat tvar-1.rc
     -| ; tvar-1.rc
     -| ;
     -| $a=foo
     -| 0 \$a:1=$a
     -| $c=$a
     -| 0 \$c=$c
     -| $b=$c bar $a
     -| 0 \$b=$b
     -| $a=bar $b baz $a booz
     -| 0 \$a:2=$a
     -| $a=
     -| $b=0 $b $c frozz $a frozz
     -| $b ->Das ist \$b
     -| 0 \$x='$x' und \$d ist nicht definiert: $d...
     -| $a= 0 ~ 1~2~\$3~%n~$c~\
     -| jetzt ist's genug!
     -| 0 \$a=---$a---
     -| $a=0 \   \ \\ Und das...
     -| $a geht auch!

So erzeugt Gcal die folgende Ausgabe:

     $ gcal %19960101 -H no -x -r '$A=FROBOZZ:$x=' -f ./tvar-1.rc
     -|
     -| Mo,   1 Jan 1996:    \ \\ Und das... geht auch!
     -| Mo,   1 Jan 1996: $a:1=foo
     -| Mo,   1 Jan 1996: $a:2=bar foo bar foo baz foo booz
     -| Mo,   1 Jan 1996: $a=--- 0
     -|                    1
     -|                   2
     -|                   $3
     -|                   01-Jan-1996
     -|                   foo
     -|                   jetzt ist's genug!---
     -| Mo,   1 Jan 1996: $b=foo bar foo
     -| Mo,   1 Jan 1996: $c=foo
     -| Mo,   1 Jan 1996: $x='' und $d ist nicht definiert: $d...
     -| Mo,   1 Jan 1996: foo bar foo foo frozz FROBOZZ frozz ->Das ist $b

Oder es existiert eine Ressourcendatei mit dem Namen `tvar-2.rc' und
folgendem Inhalt:

     $ cat tvar-2.rc
     -| ; tvar-2.rc
     -| ;
     -| $a=$b foo
     -| $b=0@e
     -| $a bar
     -| $b \$b
     -| 0 \$a:$a
     -| 0 \$b:$b

So erzeugt Gcal die folgenden Ausgaben:

     $ gcal %19960101 -H no -x -f ./tvar-2.rc
     -|
     -| Mo,   1 Jan 1996: $a:0@e foo
     -| Mo,   1 Jan 1996: $b:0@e
     $ gcal %19960101 -H no -x -f ./tvar-2.rc -y
     -|
     -| So,   7 Apr 1996: $b
     -| So,   7 Apr 1996: foo bar

Wie zuvor gesehen können vollständige (oder auch teilweise) Datumteile
(*note Datumteil einer Zeile::), sowie Spezialtexte (*note `%?'...
Spezialtexte: Spezialtexte.)  in Textvariablen angegeben werden, oder
auch Referenzen auf andere Textvariablen, welche nach Expansion der
Textvariablen von Gcal verarbeitet werden.  *Note Beschreibung aller
`%?'... Spezialtexte: Spezialtexte (lang), für Einschränkungen
hinsichtlich der Zuweisung von Spezialtexten an Textvariablen.

Textvariablen, die in einer Ressourcendatei definiert werden, sind
stets lokal und werden nur in dieser spezifischen Datei *und*
derjenigen Datei respektiert, welche in diese eingefügt wird.  Das
bedeutet hinsichtlich der eingefügten Datei, daß alle lokalen Variablen
der aufrufenden Datei sichtbar sind.  Die eingefügte Datei selbst darf
eigene lokale Variablen definieren, welche dann die bereits an anderer
Stelle definierten lokalen Variablen überdecken, und welche bei
Weiterverarbeitung der aufrufenden Datei nicht exportiert werden.  Alle
anderen Definitionen von Textvariablen(2) (*note
Textvariablen-Footnote-2::) sind stets global.  Falls eine Zeile einer
Ressourcendatei eine Referenz auf eine Textvariable enthält, die nicht
lokal in dieser Datei definiert ist, so wird Gcal versuchen, die Werte
der entsprechenden globalen Variablen zu benutzen.  Sollte dieses nicht
gelingen, da keine globale Definition dieser Textvariablen vorliegt, so
wird Gcal den Namen dieser Textvariablen unverändert in der Zeile
belassen.  Allerdings wird bei einer lokalen Textvariablen, die mit
einem _leeren Inhalt_ definiert wurde, nicht deren Name unverändert in
der Zeile belassen falls keine globale Definition dieser Textvariablen
vorgefunden wird, sondern diese wird vollständig von der Verarbeitung
ausgenommen und erscheint auch nicht in der Ausgabe.

Hierzu ein Beispiel.  Angenommen, es existiert eine Ressourcendatei mit
dem Namen `tvar-3.rc' und folgendem Inhalt:

     $ cat tvar-3.rc
     -| ; tvar-3.rc
     -| ;
     -| $c=+00+000
     -| $h=
     -| $d=$c$h
     -| 0 %o$d  %s$d
     -| 0 \$c=$c  \$h=$h  \$d=$d  \$x=$x

So erzeugt Gcal die folgenden Ausgaben:

     $ gcal -QUx -f ./tvar-3.rc
     -| $c=+00+000  $h=  $d=+00+000  $x=$x
     -| 05:55 18:02
     $ gcal -QUx -r '$h=+1000:$x=' -f ./tvar-3.rc
     -| $c=+00+000  $h=+1000  $d=+00+000+1000  $x=
     -| 05:50 18:07

Nur fortgeschrittene Benutzer sollten die `--export-text-variables'
Option benutzen, welche bewirkt, daß die aktuelle Inkarnation einer
lokalen Textvariablen --welche zuvor in einer Ressourcendatei definiert
wurde und nicht in einer eingefügten Datei-- an weitere
Ressourcendateien exportiert wird, anstelle der Benutzung deren
globalen Wertes, falls diese Textvariable nicht lokal in dieser
weiteren Ressourcendatei definiert ist.  *Note Einfügeanweisungen:
Einfuegeanweisungen, für weitere Details.

Aber seien Sie vorsichtig, die Benutzung dieser Option könnte
unerwartete Ergebnisse erzeugen, da die Reihenfolge der Abarbeitung der
Ressourcendateien eine wichtige Größe hinsichtlich der Wirkung der
`--export-text-variables' Option ist, so daß es nicht empfohlen werden
kann, diese Option zu benutzen.  Sie, der Benutzer, müssen sehr genau
wissen was Sie mit dieser Option bezwecken wollen; *Sie seien nun
ausdrücklich gewarnt!*

Einige grundlegende Operationen können auf Textvariablen ausgeführt
werden, sofern diese einen ganzzahligen Inhalt haben.  Diese sind:

*Operation*    *Beschreibung*

`TVAR++'       Einfache Inkrementierung um eins.
`TVAR--'       Einfache Dekrementierung um eins.
`TVAR+=[+|-]N' Addition eines konstanten numerischen Faktors [+|-]N.
`TVAR-=[+|-]N' Subtraktion eines konstanten numerischen Faktors [+|-]N.

Hier folgt nun ein Beispiel, wie Operationen auf Textvariablen von Gcal
verarbeitet werden.  Angenommen, es existiert eine Ressourcendatei mit
dem Namen `tvaro-1.rc' und dem folgenden Inhalt:

     $ cat tvaro-1.rc
     -| ; tvaro-1.rc
     -| ;
     -| $a=130
     -| $b=2
     -| 0 1. \$b=$b
     -| $b++
     -| 0 2. \$b=$b
     -| $b+=7
     -| 0 3. \$b=$b
     -| $b--
     -| 0 4. \$b=$b
     -| $b-=-5
     -| 0 5. \$b=$b
     -| $b+=123
     -| 0 6. \$b=$b
     -| $b-=$a
     -| 0 7. \$b=$b
     -| $b-=10000
     -| 0 8. \$b=$b
     -| $b+=10000
     -| 0 9. \$b=$b
     -| $b=02
     -| 0 a. \$b=$b
     -| $b++
     -| 0 b. \$b=$b

So erzeugt Gcal die folgende Ausgabe:

     $ gcal -QUx -f ./tvaro-1.rc
     -| 1. $b=2
     -| 2. $b=3
     -| 3. $b=10
     -| 4. $b=09
     -| 5. $b=14
     -| 6. $b=137
     -| 7. $b=007
     -| 8. $b=-9993
     -| 9. $b=00007
     -| a. $b=02
     -| b. $b=03

Wie man aus dem vorherigen Beispiel ersehen kann, ist die
Grundeinstellung von Gcal so, daß es bei den vorgenommenen Operationen
längenkonservierend mit führenden Nullen auffüllt, falls ein
stattgefundener Übertrag in eine der nächsten Dezimalstellen an einem
späteren Platz in der Ressourcendatei per Operation wieder
zurückgenommen wird.  Dieses Standardverhalten kann aber durch die
Benutzung der bereits zuvor erwähnten Formatanweisung abgestellt bzw.
geändert werden.

Der Gültigkeitsbereich der Definitionen, welche auf eine lokale
Textvariable durchgeführt werden, erstreckt sich auf die Ressourcendatei
oder die eingefügte Datei, in welcher die lokale Textvariable definiert
wurde.

Falls Redefinitionen einer globalen Textvariable in einer
Ressourcendatei oder in derjenigen Datei, die in diese eingefügt wird,
durchgeführt werden, so sind diese Redefinitionen nur in dieser
entsprechenden Datei gültig(3) (*note Textvariablen-Footnote-3::),
nicht aber in weiteren Ressourcendateien, welche verarbeitet werden.
Das bedeutet, daß die Initialwerte der globalen Textvariablen stets
restauriert werden, falls die zu verarbeitende Ressourcendatei wechselt.

Bitte beachten Sie abschließend, daß jede Zuweisung an eine
Textvariable oder Operation auf eine Textvariable in einer separaten
Zeile der Ressourcendatei erfolgen muß.


File: gcal.info,  Node: Textvariablen-Footnotes,  Up: Textvariablen

(1) Groß- bzw. Kleinbuchstaben werden nicht unterschieden.

(2) In der Kommandozeile, Umgebungsvariable `GCAL' oder Antwortdatei.

(3) Diese werden nur lokal ausgeführt.


File: gcal.info,  Node: Ressourcendateibeispiele,  Prev: Ressourcendatei,  Up: Termine

Ressourcendateibeispiele
========================

Um einen konkreten Eindruck von den Einsatzmöglichkeiten aller die
Termine betreffenden Eigenschaften von Gcal zu erhalten, folgen nun
einige Beispiele problembezogener Ressourcendateien.

Zunächst als ganz allgemeines Beispiel, die Ressourcendatei `common.rc':

     $ cat common.rc
     -| ; common.rc, ein allgemeines Beispiel einer Ressourcendatei.
     -| ;
     -| 19940715 Lokalzeit: %t  --> Zahnarzttermin um 10:00 Uhr
     -| 00000921 Mein %B1962  Geburtstag%i1962#2062
     -| 0000093 Die~Gregorianische Reformation\~war vor %y1582  Jahren
     -| 0000Sep03 Die~Gregorianische Reformation\~war vor %y1582  Jahren
     -| 0 Jeder Tag in jedem Monat in jedem Jahr
     -| 0000 Jeder Tag in jedem Monat in jedem Jahr
     -| 00000000 Jeder Tag in jedem Monat in jedem Jahr
     -| 199400fre        Immer Freitags 1994
     -| 000007mo3 Jeder 3. Montag im Juli~jeden Jahres kleiner 1980%i#1979
     -| 0000@e-10 Ostersonntag-10 Tage in jedem Jahr
     -| 0@e-10 Ostersonntag-10 Tage in jedem Jahr
     -| 0000@e+10 Ostersonntag+10 Tage in jedem Jahr
     -| a=1127
     -| 0@a+20 20 Tage nach dem Datum der Datumvariablen `a'
     -| a=*W10FR
     -| 0@a-1 Der Donnerstag der 10'ten Woche in jedem Jahr
     -| 0@a   Der Freitag der 10'ten Woche in jedem Jahr
     -| 0@a1  Der Samstag der 10'ten Woche in jedem Jahr
     -| 1995*d10    Der 10'te absolute Tag in 1995
     -| 1995*d99die Der letzte Dienstag in 1995
     -| 0*w99so Der Sonntag der letzten Woche in jedem Jahr
     -| ;
     -| ; Der folgende Eintrag wird von ALLEN
     -| ;   Terminzeitraum-Modifizierern verarbeitet.
     -| ;
     -| 1994*d1sun#99SON.7 Jeder Sonntag in 1994
     -| ;
     -| ; Buss- und Bettag ist der Mittwoch vor dem Sonntag,
     -| ;   der vor dem 1'ten Adventssonntag liegt.
     -| ;
     -| a=1225
     -| a=a-5so
     -| 0@a-4 Buss- und Bettag
     -| ; oder
     -| 0@a-1mit Buss- und Bettag

Und hier eine Ressourcendatei mit dem Dateinamen `demo-1.rc', mit der
alle Freitage bestimmt werden können, die auf den 13'ten Tag eines
Monats fallen:

     $ cat demo-1.rc
     -| ; demo-1.rc
     -| ;
     -| $a=Freitag der 13'te%i0000
     -| $b=#0000
     -| $c=fr2
     -| $d=fr3
     -| 00000113 $a01$c$b01$c
     -| 00000113 $a01$d$b01$d
     -| 00000213 $a02$c$b02$c
     -| 00000213 $a02$d$b02$d
     -| 00000313 $a03$c$b03$c
     -| 00000313 $a03$d$b03$d
     -| 00000413 $a04$c$b04$c
     -| 00000413 $a04$d$b04$d
     -| 00000513 $a05$c$b05$c
     -| 00000513 $a05$d$b05$d
     -| 00000613 $a06$c$b06$c
     -| 00000613 $a06$d$b06$d
     -| 00000713 $a07$c$b07$c
     -| 00000713 $a07$d$b07$d
     -| 00000813 $a08$c$b08$c
     -| 00000813 $a08$d$b08$d
     -| 00000913 $a09$c$b09$c
     -| 00000913 $a09$d$b09$d
     -| 00001013 $a10$c$b10$c
     -| 00001013 $a10$d$b10$d
     -| 00001113 $a11$c$b11$c
     -| 00001113 $a11$d$b11$d
     -| 00001213 $a12$c$b12$c
     -| 00001213 $a12$d$b12$d

Für die Jahre 1996...2002 ist das Ergebnis wie folgt:

     $ LANGUAGE=en gcal -H no -u -x -f ./demo-1.rc 1996+2002
     -|
     -| Fri, Sep  13th 1996: Freitag der 13'te
     -| Fri, Dec  13th 1996: Freitag der 13'te
     -|
     -| Fri, Jun  13th 1997: Freitag der 13'te
     -|
     -| Fri, Feb  13th 1998: Freitag der 13'te
     -| Fri, Mar  13th 1998: Freitag der 13'te
     -| Fri, Nov  13th 1998: Freitag der 13'te
     -|
     -| Fri, Aug  13th 1999: Freitag der 13'te
     -|
     -| Fri, Oct  13th 2000: Freitag der 13'te
     -|
     -| Fri, Apr  13th 2001: Freitag der 13'te
     -| Fri, Jul  13th 2001: Freitag der 13'te
     -|
     -| Fri, Sep  13th 2002: Freitag der 13'te
     -| Fri, Dec  13th 2002: Freitag der 13'te

Oder eine etwas kürzere Version der Ressourcendatei `demo-1.rc' mit dem
Dateinamen `demo-2.rc', mit der ebenfalls alle Freitage bestimmt werden
können, die auf den 13'ten Tag eines Monats fallen, und zwar unter
Ausnutzung der Tatsache, daß ein Freitag als 13'ter Tag des Monats nur
dann auftreten kann, wenn der erste Tag des Monats ein Sonntag ist:

     $ cat demo-2.rc
     -| ; demo-2.rc
     -| ;
     -| $a=Freitag der 13'te ist am %n+12%i0000
     -| $b=#0000
     -| $c=sun1
     -| 00000101 $a01$c$b01$c
     -| 00000201 $a02$c$b02$c
     -| 00000301 $a03$c$b03$c
     -| 00000401 $a04$c$b04$c
     -| 00000501 $a05$c$b05$c
     -| 00000601 $a06$c$b06$c
     -| 00000701 $a07$c$b07$c
     -| 00000801 $a08$c$b08$c
     -| 00000901 $a09$c$b09$c
     -| 00001001 $a10$c$b10$c
     -| 00001101 $a11$c$b11$c
     -| 00001201 $a12$c$b12$c

Für die Jahre 1996...2002 ist das Ergebnis wie folgt:

     $ LANGUAGE=en gcal -H no -u -x -f ./demo-2.rc 1996+2002
     -|
     -| Sun, Sep   1st 1996: Freitag der 13'te ist am 13-Sep-1996
     -| Sun, Dec   1st 1996: Freitag der 13'te ist am 13-Dec-1996
     -|
     -| Sun, Jun   1st 1997: Freitag der 13'te ist am 13-Jun-1997
     -|
     -| Sun, Feb   1st 1998: Freitag der 13'te ist am 13-Feb-1998
     -| Sun, Mar   1st 1998: Freitag der 13'te ist am 13-Mar-1998
     -| Sun, Nov   1st 1998: Freitag der 13'te ist am 13-Nov-1998
     -|
     -| Sun, Aug   1st 1999: Freitag der 13'te ist am 13-Aug-1999
     -|
     -| Sun, Oct   1st 2000: Freitag der 13'te ist am 13-Oct-2000
     -|
     -| Sun, Apr   1st 2001: Freitag der 13'te ist am 13-Apr-2001
     -| Sun, Jul   1st 2001: Freitag der 13'te ist am 13-Jul-2001
     -|
     -| Sun, Sep   1st 2002: Freitag der 13'te ist am 13-Sep-2002
     -| Sun, Dec   1st 2002: Freitag der 13'te ist am 13-Dec-2002

Natürlich kann vorstehender Aufwand zur Ermittlung aller Freitage, die
auf den 13'ten eines Monats fallen, auch textlich recht drastisch
reduziert werden, indem einfach nur

     0*d1fre#99fre.7 Freitag der 13'te%i00000013#00000013

in der Ressourcendatei `demo-1.rc' benutzt wird, beziehungsweise

     0*d1son#99son.7 Freitag der 13'te ist am %n+12%i00000001#00000001

in der `demo-2.rc' Ressourcendatei benutzt wird.

Allerdings muß hier klar gesagt werden, daß vorstehende _Einzeiler_
zwar den Kodieraufwand in einer Ressourcendatei erheblich reduzieren
--von 28 bzw. 15 Zeilen auf jeweils 1 Zeile--, aber der Prüfaufwand
dieser _Einzeiler_ allerdings zum Teil erheblich höher ist, was sich
dann an einer längeren Programmlaufzeit bemerkbar macht.  Beide
_Einzeiler_ verursachen intern circa 52 Produktionen bzw.  effektive
Termineinträge ihrer selbst je Jahr, welches von Gcal abgeprüft wird,
wobei die `demo-1.rc' und `demo-2.rc' Ressourcendateien nur zu 24 bzw.
12 effektiven Termineinträgen auslaufen.

Und hier eine Ressourcendatei mit dem Dateinamen `demo-3.rc', mit der
alle Werktage eines beliebigen Monats bestimmt werden können:

     $ cat demo-3.rc
     -| ; demo-3.rc
     -| ;
     -| $a=%VWerktag
     -| $c=%i#0000$b99
     -| a=$bmo1
     -| 0@a#+4 $a
     -| a=$bdi1
     -| 0@a#+3 $a
     -| a=$bmi1
     -| 0@a#+2 $a
     -| a=$bdo1
     -| 0@a#+1 $a
     -| a=$bfr1
     -| 0@a $a
     -| a=$bmo2
     -| 0@a#+4 $a
     -| a=$bmo3
     -| 0@a#+4 $a
     -| a=$bmo4
     -| 0@a#+4 $a$c
     -| a=$bmo9
     -| 0@a#+4 $a$c

Beziehungsweise eine etwas kürzere Version der Ressourcendatei
`demo-3.rc':

     ; demo-3.rc
     ;
     $a=%VWerktag
     $c=%i#0000$b99
     0000$bmo1:5 $a
     0000$bdi1:4 $a
     0000$bmi1:3 $a
     0000$bdo1:2 $a
     0000$bfr1:1 $a
     0000$bmo2:5 $a
     0000$bmo3:5 $a
     0000$bmo4:5 $a$c
     0000$bmo9:5 $a$c

Und es existiert eine Ressourcendatei mit dem Namen `include.rc', die
nur zur Einfügung einer beliebigen Ressourcendatei gedacht ist:

     $ cat include.rc
     -| #include "$f"

Dann ist das Ergebnis für den Monat August 1996 wie folgt:

     $ gcal -H no -u -x -r '$b=08:$f=demo-3.rc' -f ./include.rc Aug 1996
     -|
     -| Do,   1 Aug 1996: Werktag
     -| Fr,   2 Aug 1996: Werktag
     -| Mo,   5 Aug 1996: Werktag
     -| Di,   6 Aug 1996: Werktag
     -| Mi,   7 Aug 1996: Werktag
     -| Do,   8 Aug 1996: Werktag
     -| Fr,   9 Aug 1996: Werktag
     -| Mo,  12 Aug 1996: Werktag
     -| Di,  13 Aug 1996: Werktag
     -| Mi,  14 Aug 1996: Werktag
     -| Do,  15 Aug 1996: Werktag
     -| Fr,  16 Aug 1996: Werktag
     -| Mo,  19 Aug 1996: Werktag
     -| Di,  20 Aug 1996: Werktag
     -| Mi,  21 Aug 1996: Werktag
     -| Do,  22 Aug 1996: Werktag
     -| Fr,  23 Aug 1996: Werktag
     -| Mo,  26 Aug 1996: Werktag
     -| Di,  27 Aug 1996: Werktag
     -| Mi,  28 Aug 1996: Werktag
     -| Do,  29 Aug 1996: Werktag
     -| Fr,  30 Aug 1996: Werktag

So kann auch hier vorstehender Aufwand zur Ermittlung aller Werktage
eines beliebigen Monats textlich recht drastisch reduziert werden,
indem einfach nur

     00000001#0099 %V%rWerktag

in der Ressourcendatei `demo-3.rc' benutzt wird.

Es folgt noch die Ressourcendatei mit dem Namen `sun-1.rc', welche die
aktuellen Ortszeiten zweier geographischer Orte, deren ungefähre
Sonnenaufgangs- und untergangszeiten sowie deren Tages- und Nachtlängen
ermittelt:

     $ cat sun-1.rc
     -| ; sun-1.rc, Vergleich von Sonnenauf- und untergang, Tageslaenge
     -| ; und Nachtlaenge zweier Orte, naemlich:  Muenster.DE / Bangkok.TH
     -| ; Alle Bezuege basieren auf Muenster.DE!
     -| ;
     -| ; Allgemeine Definitionen
     -| $p=0*d1#999
     -| $v=%2%4 nach dortiger Ortszeit
     -| $z=aktuelle Ortszeit in
     -| ; Definitionen fuer Winterzeit
     -| $a=%e#1980 %e0@a#0@b-1
     -| $x=Sonne:~%o$c,$w auf, %s$c,$w unter, %u$c,$w tag, %z$c,$w nacht~$l
     -| ; Winterzeit in Deutschland == MEWZ/GMT-1 (+60 Minuten)
     -| $w=+60
     -| ; Beginn der Winterzeit in Deutschland
     -| b=10son9
     -| ; Definitionen fuer Sommerzeit
     -| $b=%e#1980 %i0@a#0@b-1
     -| $y=Sonne:~%o$c,$s auf, %s$c,$s unter, %u$c,$s tag, %z$c,$s nacht~$l
     -| ; Sommerzeit in Deutschland == MESZ/GMT-2 (+120 Minuten)
     -| $s=+120
     -| ; Beginn der Sommerzeit in Deutschland
     -| a=03son9
     -| ; Geographische Koordinate und Name des Orts Muenster, Deutschland
     -| $c=+5158+00738+61
     -| $l=%1Muenster
     -| ; Muensters Sonnenaufgang etc. nach dortiger Ortszeit
     -| $p $a $x$v
     -| $p $b $y$v
     -| ; Muensters aktuelle Ortszeit
     -| 0 $a %1%@$w %2 $z $l
     -| 0 $b %1%@$s %2 $z $l
     -| ; Geographische Koordinate und Name des Orts Bangkok, Thailand
     -| $c=+1345+10031+10
     -| $l=%3Bangkok%4-Zeit umgerechnet in $ls%2 Ortszeit
     -| ; Bangkok Sonnenaufgang etc. umgerechnet in Muensters Ortszeit
     -| $p $a $x
     -| $p $b $y
     -| ; Bangkok Ortszeit == WAST/GMT-7 (+420 Minuten)
     -| $t=+420
     -| $w=$t
     -| ; Bangkoks aktuelle Ortszeit
     -| $l=%3Bangkok
     -| 0 $a %3%@$t %4 $z $l
     -| 0 $b %3%@$t %4 $z $l
     -| ; Bangkoks Sonnenaufgang etc. nach dortiger Ortszeit
     -| $l=$l$v
     -| $p $x

Für den 12'ten September 1999 ist das Ergebnis wie folgt:

     $ gcal -fsun-1.rc -Ux -Hno
     -|
     -| 04:02/12-Sep-1999 aktuelle Ortszeit in Muenster
     -| 09:02/12-Sep-1999 aktuelle Ortszeit in Bangkok
     -| Sonne:
     -| 01:06auf, 13:22unter, 12h16'tag, 11h44'nacht
     -| Bangkok-Zeit umgerechnet in Muensters Ortszeit
     -| Sonne:
     -| 06:06auf, 18:22unter, 12h16'tag, 11h44'nacht
     -| Bangkok nach dortiger Ortszeit
     -| Sonne:
     -| 06:56auf, 19:54unter, 12h58'tag, 11h02'nacht
     -| Muenster nach dortiger Ortszeit

Als nächstes Beispiel betrachten wir noch die Ressourcendatei mit dem
Namen `redir-1.rc', welche den Einsatz des shell Kommando
`%![ARGUMENT]' Spezialtexts demonstriert, und die wie folgt aussieht:

     $ cat redir-1.rc
     -| ; redir-1.rc, shell Kommando $c ausfuehren und nach $f umlenken
     -| ;
     -| $p=0*d1#999
     -| $c=$p %!$c
     -| $g=|txt2gcal - $p
     -| ;
     -| $c $g>$f

Bei Benutzung nachstehenden Aufrufs von Gcal, dem zum besseren
Verständnis des Programmablaufs auch noch die `--debug=all' Option
hinzugefügt werden kann, ist das Ergebnis wie folgt:

     $ gcal --exe -QUx -f./redir-1.rc+XX -r'$f=XX:$c=echo $f' -#'0 %!rm $f'
     -| XX

Und abschließend eine Ressourcendatei mit dem Namen `swtim-1.rc', die
Termine für den Zeitraum zwei Tage vor bis zwei Tage nach Umstellung
auf Sommerzeit/Winterzeit (ab 1981) für die Bundesrepublik Deutschland
bewirkt:

     $ cat swtim-1.rc
     -| ; swtim-1.rc, Sommerzeit/Winterzeit BRD
     -| ;
     -| $a=zeitumstellung am Sonntag
     -| ;
     -| a=03sun9
     -| 0@a-2#+2 Sommer$a~+1 Std. (02:00 --> 03:00 Uhr)%i1981
     -| ;
     -| a=09sun9
     -| 0@a-2#+2 Winter$a~-1 Std. (03:00 --> 02:00 Uhr)%i1981#1995
     -| ;
     -| a=10sun9
     -| 0@a-2#+2 Winter$a~-1 Std. (03:00 --> 02:00 Uhr)%i1996

Für das Jahr 1998 ist das Ergebnis wie folgt:

     $ LANGUAGE=en gcal %1998 -Hno -xy -f ./swtim-1.rc
     -|
     -| Fri, Mar  27th 1998: Sommerzeitumstellung am Sonntag
     -|                      +1 Std. (02:00 --> 03:00 Uhr)
     -| Sat, Mar  28th 1998: Sommerzeitumstellung am Sonntag
     -|                      +1 Std. (02:00 --> 03:00 Uhr)
     -| Sun, Mar  29th 1998: Sommerzeitumstellung am Sonntag
     -|                      +1 Std. (02:00 --> 03:00 Uhr)
     -| Mon, Mar  30th 1998: Sommerzeitumstellung am Sonntag
     -|                      +1 Std. (02:00 --> 03:00 Uhr)
     -| Tue, Mar  31st 1998: Sommerzeitumstellung am Sonntag
     -|                      +1 Std. (02:00 --> 03:00 Uhr)
     -| Fri, Oct  23rd 1998: Winterzeitumstellung am Sonntag
     -|                      -1 Std. (03:00 --> 02:00 Uhr)
     -| Sat, Oct  24th 1998: Winterzeitumstellung am Sonntag
     -|                      -1 Std. (03:00 --> 02:00 Uhr)
     -| Sun, Oct  25th 1998: Winterzeitumstellung am Sonntag
     -|                      -1 Std. (03:00 --> 02:00 Uhr)
     -| Mon, Oct  26th 1998: Winterzeitumstellung am Sonntag
     -|                      -1 Std. (03:00 --> 02:00 Uhr)
     -| Tue, Oct  27th 1998: Winterzeitumstellung am Sonntag
     -|                      -1 Std. (03:00 --> 02:00 Uhr)


File: gcal.info,  Node: Heutiger Kalender,  Next: Gcal Hilfsprogramme,  Prev: Termine,  Up: Top

Entstehungsgeschichte des Gregorianischen Kalenders
***************************************************

Der heutzutage benutzte Kalender wurde --basierend auf Verfahren, die
von den Babyloniern und Ägyptern entwickelt wurden-- zuerst von den
Römern in zahlreichen ungenauen Variationen formuliert, die alle zum
Ziel hatten, den Mond- und Sonnenlauf in Einklang zu bringen.  So kam
es, daß in der Zeit des Julius Cäsar der Monat Januar in den Herbst
fiel.  Auf Cäsars Befehl hin wurde von Sosigenes eine Kalenderreform
durchgeführt.  Dieser addierte 90 Tage zu dem Jahr 46 vor Christus, um
den bis dahin aufgelaufenen jahreszeitlichen Versatz zu korrigieren.
Zudem modifizierte er die Monatslängen ähnlich der Form, wie wir sie
heute noch benutzen.  Weiterhin wurde das Schaltjahr von ihm
eingeführt, indem alle vier Jahre ein weiterer Tag im Monat Februar
hinzuaddiert wurde.  Die Schaltjahrregelung sah zunächst so aus, daß
alle vier Jahre nach dem 23'ten Tag im Februar ein Schalttag eingelegt
wurde, der 24'te Februar wurde zu einem Doppeltag, fand also zweimal
statt.  Die Benutzung eines Schaltjahres war eine echte Verbesserung der
Kalenderrechnung, aber noch nicht in vollem Umfang exakt.

In den folgenden Jahren wurde die Schaltregel aber falsch angewendet,
und so wurden durch Kaiser Augustus im Jahre 8 vor Christus die Fehler
korrigiert.  Dabei kam es zu einem kuriosen Nachspiel.  Da Augustus mit
großer Eifersucht auf alles reagierte, was zuvor Julius Cäsar getan bzw.
angestrengt hatte, ertrug er auch nicht dessen Ehrung im Kalender, den
heutigen Monat *Juli*.  Er ließ er kurzerhand einen anderen Monat nach
sich selbst umbenennen, und so entstand der Monatsname *August*.
Weiterhin duldete Augustus nicht, daß sein Geburtsmonat August im Sinne
der regelmäßigen Abfolge von Monaten mit 30 und 31 Tagen kürzer war als
der Monat Cäsars.  Konsequenterweise bekam der August ebenfalls 31 Tage.
Dafür mußte der Februar noch weiter, auf 28 bzw. 29 Tage, schrumpfen,
so daß nun der 29'te Februar zum Schalttag wurde.

Dieser Kalender ist als der "Julianische Kalender" in die
Geschichtsschreibung eingegangen und hat ein reines Sonnenjahr zur
Grundlage.  Die Solllänge eines Sonnenjahres (bzw. so genannten
tropischen Jahres) beträgt 365 Tage, 5 Stunden, 48 Minuten und 46
Sekunden.  Ein 366-Tage Jahr, welches alle vier Jahre stattfindet,
setzt nun aber die Durchschnittslänge von einem Julianischen Jahr auf
365 Tage und 6 Stunden, also auf 365,25 Tage.  Das bedeutet somit, daß
sich alle vier Jahre ein Fehler von 44 Minuten und 56 Sekunden in diese
Kalenderrechnung einschleicht.  Die Jahre werden aufgrund dieser
Zählweise etwas zu lang, und zwar um gut 11 Minuten.

So kam es, daß der Frühlingsanfang im 16'ten Jahrhundert auf den 11'ten
März fiel --anstatt auf den 21'ten März--, und zwar durch einen bis
dahin akkumulierten Fehler von zehn Tagen.  Auch das Osterfest rückte
stets mehr und mehr vom gewohnten Frühlingstermin ab und mußte immer
früher gefeiert werden.  Papst Gregor XIII ordnete eine weitere
Kalenderreform an, um diesen Fehler zu kompensieren.  So wurde der
Frühlingsanfang auf den 21'ten März festgelegt und Donnerstag, der 4'te
Oktober, wurde gefolgt von Freitag, dem 15'ten Oktober, indem einfach
zehn Tage im Kalender übersprungen wurden.  Zudem wurde alle 400 Jahre
ein Schaltjahrhundert eingeführt und weiterhin bestimmt, daß die
Jahrhundertwenden keine Schaltjahre mehr sind, mit der Ausnahme, daß
Jahrhundertwenden, die durch 400 ganzzahlig teilbar sind, dennoch
Schaltjahre bleiben sollten.  Diese Regelung verminderte den Fehler in
der Kalenderrechnung um weitere 72 Stunden (3 Tage) alle 400 Jahre.
Der aktuelle Überschuß beträgt akkumuliert 74 Stunden, 53 Minuten und
20 Sekunden.  Der Fehler von 2 Stunden, 53 Minuten und 20 Sekunden pro
Zeitraum von 400 Jahren beläuft sich auf einen Tag in circa 3300 Jahren.
Damit hat das Gregorianische Jahr eine Durchschnittslänge von 365,2425
Tagen.

Dieser "Gregorianische Kalender" setzte sich aber nur sehr langsam
durch.  Katholisch regierte Länder übernahmen den Gregorianischen
Kalender sofort oder innerhalb weniger Jahre.  Die meisten
protestantisch regierten Länder auf dem europäischen Kontinent
übernahmen den neuen Gregorianischen Kalender um 1700.  England und die
amerikanischen Kolonien wechselten zu dem Kalender im Jahre 1752 durch
Parlamentsbeschluß.  Orthodox christianisierte Länder übernahmen den
Gregorianischen Kalender später.  Rußland war das letzte europäische
Land, daß diesen Kalender übernahm, und zwar nach der Kommunistischen
Revolution, welche am 25'ten Oktober 1917 (Gregorianisch) stattfand.
Daraus resultierte, daß die frühere UdSSR den Tag der Oktoberrevolution
nach dem alten Julianischen Kalender am 7'ten November feierte.

Heute ist die weltweit einheitliche Zeitrechnung schon bereits wieder
Geschichte geworden.  So ist der Iran im Jahre 1979 nach Absetzung des
Schah-Regierung wieder zum traditionellen mohammedanischen Mondkalender
zurückgekehrt.  Es gibt auch einige Bemühungen, unseren gegenwärtig
gültigen Gregorianischen Kalender zu verbessern.  Die Nachteile bestehen
darin, daß ein bestimmter Kalendertag nicht immer auf den gleichen
Wochentag fällt.  Zudem sind die Monate ungleich lang und die an das
Osterfest gebundenen Feiertage verschieben sich innerhalb des Kalenders
von Jahr zu Jahr.  Ein recht ausgereifter Vorschlag wurde von den
Vereinten Nationen vorgetragen.  Seine internationale Einführung
scheiterte jedoch am Widerstand einiger Länder, aber auch der Kirchen.


File: gcal.info,  Node: Gcal Hilfsprogramme,  Next: Internationalisierung,  Prev: Heutiger Kalender,  Up: Top

Gcal Hilfsprogramme
*******************

* Menu:

* Aufruf von tcal::      Wie starte ich das `tcal' Programm?
* Aufruf von txt2gcal::  Wie starte ich das `txt2gcal' Programm?
* Aufruf von gcal2txt::  Wie starte ich das `gcal2txt' Programm?

Drei kleine Hilfsprogramme sind im Gcal 3.00 Paket enthalten.  Das Tcal
Programm startet das Gcal Programm mit dem Datum des morgigen Tages.
Das Txt2gcal Programm erzeugt eine wortgetreue Gcal Ressourcendatei aus
einer Textdatei, und im Gegensatz dazu erstellt das Gcal2txt Programm
eine wortgetreue Textdatei aus einer Gcal Ressourcendatei.


File: gcal.info,  Node: Aufruf von tcal,  Next: Aufruf von txt2gcal,  Prev: Gcal Hilfsprogramme,  Up: Gcal Hilfsprogramme

Aufruf von `tcal'
=================

Tcal ist ein Programm, welches das Gcal Programm mit dem Datum des
morgigen Tages aufruft(1) (*note Aufruf von tcal-Footnote-1::).  Seine
Argumente sind wie folgt:

     tcal [--help | --version] | [--shift=[+|-]ZAHL] [ARGUMENT...]

Alle gegebenen ARGUMENTE werden unverändert an das Gcal Programm
übergeben.  Soll das Gcal Programm mit einem anderen Datum als dem Datum
des morgigen Tages aufgerufen werden, so kann dieses gewünschte Datum
mittels der `--shift=[+|-]ZAHL' Option vorgewählt werden, wobei
`[+|-]ZAHL' die Distanz in Tagen ist, die das gewünschte Datum vom
aktuellen Systemdatum (==heute) entfernt ist (funktioniert nur für
Gregorianische Jahre).  Die `--shift' Option muß vor allen anderen
ARGUMENTEN, die an das Gcal Programm übergeben werden, angegeben sein.

Falls eine `GCALPROG' Umgebungsvariable (*note Umgebungsvariable
`GCALPROG': x-GCALPROG.)  definiert und mit dem Dateinamen des
ausführbaren Gcal Programms gesetzt ist, so benutzt Tcal diesen
Dateinamen, um Gcal aufzurufen.  Andernfalls benutzt Tcal den beim
Kompilationsvorgang eingebrannten Dateinamen `gcal', um das Gcal
Programm aufzurufen.  Die `GCALPROG' Umgebungsvariable muß immer dann
gesetzt werden, wenn das Gcal Programm unter einem anderen Namen als
dem Standardnamen `gcal' installiert ist, da Tcal sonst das Gcal
Programm nicht automatisch ausführen kann!  Ein Programmendestatus 0
bedeutet, daß die Verarbeitung erfolgreich war, ein anderer Endestatus
verweist auf einen Fehler während der Verarbeitung.

Das Programm akzeptiert die folgenden Optionen:

`--help'
     Ausgabe eines Hilfetextes, der alle verfügbaren Optionen aufzeigt;
     sodann erfolgreiche Beendigung des Programms.

`--version'
     Ausgabe der Versionsnummer; sodann erfolgreiche Beendigung des
     Programms.

`--shift=[+|-]ZAHL'
     Legt den um `[+|-]ZAHL' vorgegebenen Versatz an Tagen bezogen auf
     das aktuelle Datum fest.


File: gcal.info,  Node: Aufruf von tcal-Footnotes,  Up: Aufruf von tcal

(1) Das entspricht der `--shift=1' Option.


File: gcal.info,  Node: Aufruf von txt2gcal,  Next: Aufruf von gcal2txt,  Prev: Aufruf von tcal,  Up: Gcal Hilfsprogramme

Aufruf von `txt2gcal'
=====================

Txt2gcal ist ein Programm, welches aus einer Textdatei eine wortgetreue
Gcal Ressourcendatei erzeugt.  Seine Argumente sind wie folgt:

     txt2gcal [--help | --version] | [TEXTDATEI | -] [DATUMTEIL]

Wird keine TEXTDATEI oder aber ein einzelnes `-' Zeichen als Argument
angegeben, so liest und verarbeitet das Programm alle Eingaben, die vom
_Standardeingabe-Gerätekanal_ kommen.  Wird kein DATUMTEIL als Argument
angegeben, so wird von Txt2gcal eine `0' für den Datumteil erzeugt.
Alle Ergebnisse werden stets auf dem _Standardausgabe-Gerätekanal_
ausgegeben.  Ein Programmendestatus 0 bedeutet, daß die Verarbeitung
erfolgreich war, ein anderer Endestatus verweist auf einen Fehler
während der Verarbeitung.

Das Programm akzeptiert die folgenden Optionen:

`--help'
     Ausgabe eines Hilfetextes, der alle verfügbaren Optionen aufzeigt;
     sodann erfolgreiche Beendigung des Programms.

`--version'
     Ausgabe der Versionsnummer; sodann erfolgreiche Beendigung des
     Programms.

Nun zu einem Beispiel, welches den Einsatz von Txt2gcal näher erläutern
soll.  Angenommen, es existiert eine Textdatei mit dem Namen
`tdemo-1.txt' und folgendem Inhalt:

     $ cat tdemo-1.txt
     -|         Hallo Freunde,
     -|
     -| Ich bin der Demotext, der lustige Zeichen und Zeichensequenzen
     -| enthaelt wie ~~ \~ % %% $a $1 %%%\
     -| %\ %s %%foo %bar \%Baz \\~ \~\ und so weiter...
     -| Ich bin gespannt darauf, wie ich von `txt2gcal' umgesetzt werde.
     -|

und Txt2gcal verarbeitet diese Datei, wobei die Ausgabe in die Datei
`tdemo-1.rc' umgelenkt wird:

     $ txt2gcal tdemo-1.txt 0*d1#999 > tdemo-1.rc
     $ cat tdemo-1.rc
     -| 0*d1#999 \        Hallo Freunde,~\
     -| ~\
     -| Ich bin der Demotext, der lustige Zeichen und Zeichensequenzen~\
     -| enthaelt wie \~\~ \\~ % %% \$a $1 %%%\ ~\
     -| %\ \%s %\%foo \%bar \\%Baz \\\~ \\~\ und so weiter...~\
     -| Ich bin gespannt darauf, wie ich von `txt2gcal' umgesetzt werde.~\

dann hat Txt2gcal nun die neue Gcal Ressourcendatei `tdemo-1.rc' aus
der Textdatei `tdemo-1.txt' erzeugt.

Abschließend erfolgt die Betrachtung, wie Gcal diese neue
Ressourcendatei interpretiert:

     $ gcal %19960101 -H no -Ax -f ./tdemo-1.rc
     -|
     -| Mo,   1 Jan 1996:
     -|         Hallo Freunde,
     -|
     -| Ich bin der Demotext, der lustige Zeichen und Zeichensequenzen
     -| enthaelt wie ~~ \~ % %% $a $1 %%%\
     -| %\ %s %%foo %bar \%Baz \\~ \~\ und so weiter...
     -| Ich bin gespannt darauf, wie ich von `txt2gcal' umgesetzt werde.
     -|

