
Diese Datei beschreibt Gcal, ein Programm um Kalender auszugeben.  Gcal
gibt Monatskalender und Jahreskalender, ewige Feiertagslisten sowie
Terminwarnungslisten auf viele verschiedene Arten und Weisen aus.  Es
berücksichtigt diejenigen Daten korrekt, welche übergangen wurden,
als der derzeitig gültige Gregorianische Kalender den vormals gültigen
Julianischen Kalender ablöste.

Copyright (C) 1994, 1995, 1996 Thomas Esken

Das ist die erste Ausgabe der Gcal Dokumentation.

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 Genehmigungvermerks 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.  Wenn Sie dieses
Werkzeug mögen, so würde ich mich sehr über eine Postkarte von Ihnen
freuen!

                                \\\_''/'
-------------------------oOO    (/o-o\)    OOo-------------------------
Thomas Esken                o  (.  "  .)  o   Internet :
Im Hagenfeld 84              \___) ~ (___/      (esken@uni-muenster.de)
D-48147 Muenster; GERMANY                     Phone    : +49 251 232585

Gcal
****

Gcal ist ein Programm um Kalender auszugeben.  Gcal gibt Monatskalender
und Jahreskalender, ewige Feiertagslisten sowie Terminwarnungslisten
auf viele verschiedene Arten und Weisen aus.  Es berücksichtigt
diejenigen Daten korrekt, welche übergangen wurden, als der derzeitig
gültige Gregorianische Kalender den vormals gültigen Julianischen
Kalender ablöste.

Das ist die Ausgabe 2.05 der Gcal Dokumentation vom 16 Juli 1996, für
Gcal 2.10.

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

                                \\\_''/'
-------------------------oOO    (/o-o\)    OOo-------------------------
Thomas Esken                o  (.  "  .)  o   Internet :
Im Hagenfeld 84              \___) ~ (___/      (esken@uni-muenster.de)
D-48147 Muenster; GERMANY                     Phone    : +49 251 232585

Einleitung
**********

Neben den üblichen und altbekannten Kalenderfunktionen wie der Ausgabe
eines Monatskalenderblatts oder eines Jahreskalenderblatts, oder der
Ausgabe einer ewigen Feiertagsliste bietet Gcal die Möglichkeit,
Termine am Tag ihres Auftretens auszugeben, und so den Benutzer auf
einen Termin hinzuweisen.  So ist es vorstellbar, daß beim Starten des
Computers oder der Arbeitssitzung dem Benutzer von Gcal alle Termine,
welche an diesem Tag wahrzunehmen sind, am Bildschirm aufgezeigt oder
via elektronischer Post zugesandt werden.

Der Zeitraum, für welchen Gcal anfallende Termine berücksichtigt,
kann vom Benutzer frei vorgewählt werden.  So können Termine, die
sich z.B. auf den morgigen Tag beziehen, ebenso wie Termine, die in der
gesamte Woche, dem gesamten Monat oder dem gesamten Jahr auftreten, von
Gcal ausgegeben werden.  Termine, die an einem bestimmten Tag des
Jahres auftreten, werden ebenso wie Termine, die relativ zu einem
anderen, vorgegebenen Datum auftreten, von Gcal ausgegeben; entweder
nur bezogen auf dieses Einzeldatum oder als Terminliste beginnend bei
einem Startdatum und endend (einschliesslich oder ausschliesslich) am
aktuellen Tag.

Es bestehen zwei Möglichkeiten, eine Terminvorschau (Termine
zukünfiger Jahre) oder eine Terminrückschau (Termine vergangener
Jahre) vorzunehmen.  So kann Gcal einerseits mittels einer Option,
welche daß vom Computer gelieferte aktuelle Systemdatum für den
Augenblick des Gcal-Programmlaufs auf ein vorgegebenes Datum setzt,
verwendet werden, um eine Terminvorschau bzw.  Terminrückschau so
vorzunehmen, als wenn das Systemdatum tatsächlich eben dieses
vorgegebene Datum wäre, so daß der zu berücksichtigende Zeitraum via
Option vom Benutzer beliebig vorgegeben werden kann.  Andererseits kann
mittels eines Kommandos veranlaßt werden, anstelle des aktuellen
Jahres ein anderes Jahr zu berücksichtigen, so daß Gcal anfallende
Termine für eben dieses andere Jahr ausgibt.  Das hat allerdings zur
Folge, daß der vorgewählte Zeitraum nicht mehr via Option vom
Benutzer beliebig gesetzt werden kann, sondern sich in diesem Fall
stets auf das gesamte Jahr bezieht.

Gcal vermag nicht nur Termine auszugeben, die für ein konkretes Datum
gespeichert wurden, z.B. `Termin am 1'ten Dezember 1995', sondern auch
Termine, die in bestimmten Abständen immer wieder auftreten.  So ist es
möglich, wiederkehrende Termine wie z.B. `Dieser Termin findet an
allen Tagen im Monat Mai 1995 statt' oder `Immer am 15'ten November
eines jeden Jahres' zu vereinbaren.  Diese Terminvereinbarungen werden
in sogenannten Ressourcendateien gespeichert, und bei Programmaufruf
kann Gcal via Option mitgeteilt werden, welche Ressourcendateien
auszuwerten sind.

Einmal für sinnvoll erachtete Aufrufe von Gcal können hinsichtlich
der an das Programm übergebenen Kommandozeilenargumente dauerhaft in
einer sogenannten Antwortdatei oder in einer shell script Datei
gespeichert werden.  Eine Antwortdatei enthält ebenso wie eine shell
script Datei alle Argumente, die an Gcal zur Verarbeitung übergeben
wurden, nur ist eine solche Antwortdatei nicht eigenständig
ablauffähig.  Wenn bei einem erneuten Aufruf von Gcal der Name dieser
automatisch erzeugten Antwortdatei via Option übergeben wird, so liest
Gcal den Inhalt dieser Antwortdatei ein und behandelt diesen so, als
wenn dieser in der Kommandozeile angegeben wäre.  Im Gegensatz dazu
wird bei Aufruf einer shell script Datei das Gcal Programm direkt mit
den in der shell script Datei gespeicherten Argumeten sowie den
zusätzlich in der Kommandozeile angegebenen Argumenten ausführt.

Um einen konkreten Eindruck von den weiteren Möglichkeiten des Gcal
Programms zu erhalten, werden nun alle verwendbaren
Kommandozeilenargumente sowie deren Bedeutung vorgestellt.

Aufruf von `gcal'
*****************

Gcal ist ein kommandozeilenorientiertes Programm.  Es wird
üblicherweise vom Kommandointerpretierer des Betriebssystems aus
aufgerufen (auch als "shell" bezeichnet; dieses Betriebssystemprogramm
interpretiert Komandozeilen und führt diese aus), und verarbeitet die
ihm übergebenen Argumente, welche Optionen und Kommandos sind.
Optionen müssen vor Kommandos angegeben werden, d.h. Gcal muß auf
folgende Art und Weise aufgerufen werden:

           gcal [ [OPTION...] [%DATUM] [@DATEI...] ]  [KOMMANDO]


Wenn Gcal ohne entsprechende Optionen aufgerufen wird bzw. kein Kommando
angegeben wird, so wird ein Kalender des laufenden Monats ausgegeben.
Wenn der Kalender eines bestimmten Jahres ausgegeben werden soll, so
muß das Jahr vollständig angegeben werden, z.B. `gcal 94' würde
nicht den Jahreskalender von 1994 ausgeben, sondern den Jahreskalender
des Jahres 94.

Werden zwei Argumente als Kommando angegeben, so bezieht sich das
*erste* Argument auf den Monat und das *zweite* Argument auf das Jahr.
Werden beim Aufruf unkorrekte Kommandos angegeben, so wird die
Programmausführung unter Benutzung interner Grundeinstellungen von
Gcal vorgenommen.

In der deutschen Programmversion wird angenommen, daß die
Gregorianische Reformation am 5'ten Oktober 1582 stattgefunden hat,
siehe *Siehe Heutiger Kalender::, und *Siehe Internationalisierung:: für
weitere Details.

Kommandozeilenargumente
=======================

Dieses Unterkapitel beschreibt alle Argumente der Kommandozeile, die von
Gcal verarbeitet werden.  Es gibt insgesamt vier verschiedene Typen von
Kommandozeilenargumenten.  Ein wichtiger Typ von Argumenten sind die
"Optionen", welche verschiedene Verhaltensweisen bei Gcal auslösen.
Andere Argumenttypen sind die `%DATUM' und die `@DATEI' Option.  Die
`%DATUM' Option setzt den Zeitraum, welcher von Gcal berücksichtigt
werden soll, auf ein vorbestimmtes Startdatum; die `@DATEI' Option
lädt Optionen und Kommandos aus einer Antwortdatei vor.  Die
wichtigsten Argumente sind die "Kommandos", welche die Zeiträume
kontrollieren, die von Gcal berücksichtigt werden.

Eine Option wird durch ein führendes Umschaltzeichen (auch "Switch"
Zeichen genannt) definiert; entweder das `-' oder das `/' Zeichen bei
traditionellen Kurzoptionen, oder zwei `--' bei den mnemotechnischen
Langoptionen; einem Kommando darf kein Umschaltzeichen vorangehen.
Optionen (inklusive `%DATUM' und `@DATEI') *müssen* vor Kommandos
angegeben werden!

Abhängig vom benutzten Betriebssystem bzw. der shell kann es sein,
daß einige der in der Kommandozeile gegebenen Argumente und Texte durch
`"' oder `'' Zeichen quotiert, bzw. durch das `\' Zeichen gegen die
Auswertung durch die shell geschützt werden müssen.

Hier folgt eine unvollständige Liste von Zeichen, die eventuell
geschützt werden müssen:

     `(', `)', `<', `>', `[', `]', `{', `}', `\', `|', `$', `@', `!',
     `&', `~', `"', `'', ``', `;'

Optionen
--------

Die Optionen, welche von Gcal verarbeitet werden, können in vier
Hauptklassen unterteilt werden.  Die Optionen der "Allgemeinen
Optionsklasse" sind die Standardoptionen, welche jede GNU Software
wenigstens teilweise aufweisen sollte.  Die "Globale Optionsklasse"
enthält Optionen, welche die vom Programm erzeugte Ausgabe
beeinflussen.  Die Optionen der "Kalender Optionsklasse" steuern das
Kalender Layout und die Optionen der "Terminwarnung Optionsklasse"
kontrollieren das Layout der Terminwarnungen und deren Intensität.

Gcal ist in der Lage Kurzoptionen sowie auch GNU Langoptionen zu
verarbeiten.  Kurzoptionen werden von einem einzelnen Umschaltzeichen
angeführt, sodann folgt ein Optionszeichen und evtl. ein Modifizierer
oder ein Argument.  Die meisten Einzelzeichenoptionen (sofern diese
kein Argument annehmen) können zu einem einzelnen Kommandozeilenwort
zusammengefasst werden: `-Ax' ist gleichwertig zu `-A -x'.  GNU
Langoptionen werden von `--' Zeichen angeführt, sodann folgt ein
Optionsname und evtl. ein Argument.  Langoptionen sowie deren Argumente
dürfen abgekürzt werden, wenn die vorgenommene Abkürzung eindeutig
ist.  Wenn ein Argument an eine Langoption übergeben werden soll, so
werden der Optionsname und das Argument mit einem `=' Zeichen verbunden.

Eckige Klammern ([ und ]) deuten an, daß eine Option ein optionales
Argument annimmt.  Das `|' Zeichen wird dazu benutzt, um mehrere zur
Auswahl stehende Argumente voneinander abzugrenzen.

Gcal verarbeitet GNU Langoptionen in einem besonderen, nicht
standardgemäßen Weg.  So unterscheidet Gcal fünf verschiedene Typen
von Langoptionen:

  1. `--foo'
     Schaltet die `--foo' Option an.

  2. `--foo=BAR'
     Schaltet die `--foo' Option mit dem benötigtem BAR Argument an.

  3. `--foo[=BAR[|...|BAR]]'
     Die `--foo' Option darf ein BAR Argument annehmen.  Falls keine
     Argumentliste gegeben ist, so darf diese Option jedes Argument
     annehmen.  Wenn aber doch eine Argumentliste gegeben ist, so darf
     diese Option genau ein Argument aus der gegebenen Liste annehmen.
     Falls in dieser Hinsicht kein Argument angewählt wird, so wird
     automatisch das erste BAR Argument aus der Argumentliste
     angenommen.

  4. `--foo=BAR|...|BAR'
     Die `--foo' Option muß genau ein BAR Argument annehmen, welches
     aus der gegebenen Argumentliste angewählt werden muß.

  5. `--foo=BAR|...|BAR|BAZ'
     Die `--foo' Option muß entweder genau ein BAR Argument annehmen,
     welches aus der gegebenen BAR Argumentliste angewählt werden muß,
     oder alternativ das BAZ Argument annehmen.

Traditionelle Kurzoptionen unterscheiden sich wie folgt:

  1. `-x'
     Schaltet die `-x' Option an.

  2. `-x BAR'
     Schaltet die `-x' Option mit dem benötigtem BAR Argument an.  Das
     BAR Argument darf durch ein führendes *whitespace* Zeichen von dem
     Kurzoptionszeichen `x' abgegrenzt werden.  Das bedeutet, daß
     folgende Notationen zur Angabe eines Arguments verwendet werden
     können, nämlich `-x BAR' und `-xBAR'.

  3. `-x[BAR|...|BAR]'
     Die `-x' Option darf einen oder mehrere BAR "Modifizierer"
     annehmen.  Modifizierer in diesem Sinne sind ein oder mehrere
     Zeichen, welche einen speziellen Modus definieren, der durch die
     `-x' Option ausgelöst wird.  Ein Modifizierer darf nicht durch
     ein führendes *whitespace* Zeichen vom Kurzoptionszeichen
     abgegrenzt werden.

Allgemeine Optionen
...................

`-?'
`-h'
`--help'
     Ausgabe eines verdichteten Hilfetextes, der die meisten aller
     verfügbaren Optionen aufzeigt; sodann erfolgreiche Beendigung des
     Programms.

`-??'
`-hh'
`--usage[=ARGUMENT]'
`--long-help[=ARGUMENT]'
     Ausgabe eines erweiterten Hilfetextes, der alle verfügbaren
     Optionen aufzeigt; sodann erfolgreiche Beendigung des Programms.
     Falls ARGUMENT angegeben wird und ein zulässiger Langoptionsname
     ist, so wird nur ein erweiterter Hilfetext zu dem angegebenen
     Langoptionsnamen ausgegeben, z.B.:

          --long-help=long-help

     gibt einen erweiterten Hilfetext zur Langoption `--long-help' aus.

     Falls ARGUMENT nur aus einem einzelnen `?' Zeichen besteht oder
     kein gültiger Langoptionsname ist, so wird eine Liste aller
     zulässigen Langoptionsnamen ausgegeben.

`-L'
`--license'
`--copyleft'
`--copyright'
     Ausgabe des Software-Lizenztextes; sodann erfolgreiche Beendigung
     des Programms.

`-V'
`--version'
     Ausgabe der Versionsnummer und der Kompilations-Optionen; sodann
     erfolgreiche Beendigung des Programms.

`--exit-status-help-127'
     Setzt den Endestatus des Programms auf 127 anstatt auf 0, wenn
     eine der anderen Optionen der *Allgemeinen Optionsklasse* benutzt
     wurde.

Globale Optionen
................

`-R DATEINAME'
`--response-file=DATEINAME'
     Inhalt der Umgebungsvariable `GCAL' (*siehe GCAL:
     Umgebungsvariablen.), und sodann die Argumente der Kommandozeile
     (in genau dieser Reihenfolge) in die Datei DATEINAME schreiben,
     d.h. Antwortdatei `Dateiname' erzeugen.  *Siehe Antwortdatei::,
     für weitere Details.

`-S DATEINAME'
`--shell-script=DATEINAME'
     Inhalt der Umgebungsvariable `GCAL' (*siehe GCAL:
     Umgebungsvariablen.), und sodann die Argumente der Kommandozeile
     (in genau dieser Reihenfolge) in die shell script Datei DATEINAME
     schreiben, d.h. shell script `Dateiname' erzeugen.  Eine
     automatisch erzeugte shell script Datei ist eigenständing
     ablauffähig und ruft Gcal direkt mit den im Script gespeicherten
     Argumenten auf.  Beim Aufruf der shell script Datei dürfen weitere
     Kommandozeilenargumente gegeben werden, welche dann zudem an Gcal
     übermittelt werden.

`--debug[=internal|handled|unhandled|all|abort]'
     Einige Debug-Informationen ausgeben.

    `--debug=internal'
          Warnungen bei Erreichen programminterner Maxima ausgeben.

    `--debug=handled'
          Wie `--debug=internal', zudem werden die Dateinamen
          ausgegeben, die gehandhabt werden.

    `--debug=unhandled'
          Wie `--debug=internal', zudem werden die Dateinamen
          ausgegeben, die nicht gehandhabt werden.

    `--debug=all'
          Wie `--debug=handled' und `--debug=unhandled' zusammen.

    `--debug=abort'
          Wie `--debug=all', und Abbruch mit Fehlerkode beim ersten
          Auftreten eines nicht gehandhabten Dateinamens; siehe *Siehe
          118: Fehlerkodes.

`-p'
`--pager'
     Sämtliche Ausgaben von Gcal entweder durch einen *externen*
     Paginierer oder durch einen einfachen, *internen* Paginierer
     lenken.  Falls eine `PAGER' Umgebungsvariable gesetzt ist, so wird
     deren Wert zum Auffinden des externen Paginiererprogramms
     berücksichtigt.  *Siehe PAGER: Umgebungsvariablen, für weitere
     Informationen.

     Falls keine `PAGER' Umgebungsvariable gesetzt ist oder aber deren
     Wert ungültig ist, so versucht Gcal den `less' Paginierer zu
     benutzen; falls dieses Programm aber während des Absuchens des
     Dateibaums unter Zuhilfenahme der `PATH' Umgebungsvariable nicht
     vorgefunden wird, so wird Gcal versuchen, das `more'
     Paginiererprogramm, wenn dieses nicht gefunden wird, das `pg'
     Paginiererprogramm in gleicher Weise aufzuspüren (1).  *Siehe
     PATH: Umgebungsvariablen.

     Falls alle diese Aktionen versagt haben sollten, so wird Gcal einen
     einfachen, eingebauten Paginierer benutzen.  Wenn der einfache
     interne Paginierer benutzt wird, so ermittelt Gcal die Anzahl der
     Zeilen, welche vor einer Eingabeaufforderung des internen
     Paginierers ausgegeben werden, nach folgenden Methoden:

       1. Gcal benutzt die Werte, die in den Umgebungsvariablen `LINES'
          und `COLUMNS' angegeben sind.  *Siehe LINES:
          Umgebungsvariablen, und siehe auch *Siehe COLUMNS:
          Umgebungsvariablen, für weitere Details.

       2. Falls vorherige Aktion versagt, so benutzt Gcal die Werte,
          die in den Umgebungsvariablen `LI' und `CO' angegeben sind.
          *Siehe LI: Umgebungsvariablen, und siehe auch *Siehe CO:
          Umgebungsvariablen, für weitere Details.

       3. Falls vorherige Aktion versagt, so benutzt Gcal eine
          systemabhängige *low-level* Funktion (unter MS-DOS, OS/2 und
          einigen anderen Betriebssystemen) und benutzt die Werte, die
          von dieser geliefert werden.

       4. Falls vorherige Aktion versagt, so benutzt Gcal die Werte,
          die in der `termcap' (2) Datei für das verwendete
          Sichtgerät vorgefunden werden (*siehe TERM:
          Umgebungsvariablen.).  Dieser Schritt wird nur auf Systemen
          ausgeführt, welche die Benutzung von Termcap unterstützen.

       5. Falls alle vorherigen Aktionen fehlschlagen, so benutzt Gcal
          Standardwerte (entweder 23 oder 24 Zeilen, 80 Spalten).

`-H yes'
`--force-highlighting'
`--highlighting=yes'
     Falls die Ausgabe des Programms "redirektioniert" (d.h. auf einen
     anderen Gerätekanal umgelenkt) wird oder in einer "pipe" (d.h. als
     Eingabedatenstrom für ein weiteres Programm dient) benutzt wird,
     so werden Hervorhebungssequenzen *nicht* automatisch in die
     entsprechenden Markierungszeichen umgesetzt, sondern unverändert
     ausgegeben.  Diese Option hat keine Wirkung, wenn die Ausgabe des
     Programms mittels elektronischer Post versendet wird, siehe auch
     *Siehe `--mail=ADRESSE': Globale Optionen.

`-H no'
`--disable-highlighting'
`--highlighting=no'
     Hervorhebungsequenz-/ Markierungszeichen Paare von aktuellen
     Tagen, Feiertagen bzw. Text unterdrücken.

`-H TEXT'
`--highlighting=TEXT'
     Setze Hervorhebungssequenz / Markierungszeichen Paare explizit.
     "Hervorhebungssequenzen" in diesem Sinne sind Folgen von
     Steuerzeichen, die eine Farbumschaltung oder eine
     Intensitätsumschaltung von auszugebendem Text bewirken.  Typische
     Steuerzeichenfolgen sind die sogenannten ANSI Escape-Sequenzen,
     welche als erstes Zeichen der Sequenz ein Escape Zeichen
     aufweisen, und danach weitere Zeichen, die die Art der ANSI
     Escape-Sequenz definieren.  "Markierungszeichen" in diesem Sinne
     sind einzelne druckbare Zeichen, die dem auszugebenden Text
     vorangehen bzw. folgen.

     Das Argument TEXT muß ein durch `:' (Doppelpunkt) Zeichen
     abgegrenzter Text der Form
     SEQ1_START:SEQ1_ENDE:SEQ2_START:SEQ2_ENDE sein.  Die *erste*
     Sequenz wird dazu benutzt den aktuellen Tag hervorzuheben, die
     *zweite* Sequenz hebt einen Feiertag hervor.  Die Sequenzen
     müssen in der Form eines Sequenzen-Paares angegeben werden;
     SEQ?_START schaltet die Hervorhebung/Markierung ein, SEQ?_ENDE
     schaltet sie wieder aus.  Es werden stets nur zwei Sequenzen-Paare
     berücksichtigt, falls mehr Sequenzen-Paare angegeben sind, so
     werden diese ignoriert.  Es dürfen entweder nur
     Hervorhebungssequenzen-Paare oder nur Markierungszeichen-Paare
     definiert werden, d.h. eine gemischte Verwendung beider
     Hervorhebungsarten ist nicht erlaubt!

     Einige Beispiele hierzu:

          `-H \x20:\x20:\x1:#' bzw.
          `--highlighting=\x20:\x20:\x1:#'
          markiert den aktuellen Tag in der Form `\x20TAGESDATUM\x20'
          (d.h. mit vorangehenden und nachfolgenden Leerzeichen) und
          Feiertage in der Form `\x1FEIERTAGSDATUM#' mit den gegebenen
          Markierungszeichen.

          `-H \x1b[34;42m:\x1b[0;40m' oder
          `-H \033[34;42m:\033[0;40m' oder
          `-H \E[34;42m:\E[0;40m'
          definiert zum Hervorheben des aktuellen Tages die hier
          angegebene ANSI Escape-Startsequenz `\x1b[34;42m' und die
          ANSI Escape-Endesequenz `\x1b[0;40m'.  Da keine
          Hervorhebungssequenzen für den Feiertag angegeben sind,
          werden die internen Grundeinstellungen der
          Hervorhebungssequenzen für diesen verwendet.  Bitte beachten
          Sie in diesem Zusammenhang den letzten Absatz in diesem
          Textteil, welcher über weitere Details informiert. *Siehe
          GCALANSI: Umgebungsvariablen.

     Steuerzeichensequenzen dürfen jedes druckbare Zeichen enthalten.
     Nichtdruckbare Zeichen können oktal oder hexadezimal kodiert
     werden.  Die Abkürzung `\E' kodiert direkt das Escape Zeichen
     (oktal `\033' bzw. hexadezimal `\x1B').

     Ein Zeichen kann durch `\NNN' (Backslash-Oktalziffer(n)) oktal
     kodiert werden, wobei N eine gültige Oktalziffer (0...7) sein
     muß.  Normalerweise müssen drei Oktalziffern angegeben werden.
     Falls der oktale Zeichenkode nur aus einer oder zwei Oktalziffern
     besteht, so müssen führende Nullen hinzugefügt werden;
     ausgenommen, das kodierte Oktalzeichen wird zuletzt in einer
     Einzelsequenz angegeben.

     Ein Zeichen kann durch `\xNN' (Backslash-x-Hexadezimalziffer(n))
     hexadezimal kodiert werden, wobei N eine gültige Hexadezimalziffer
     (0...9A...Fa...f) sein muß.  Normalerweise müssen zwei
     Hexadezimalziffern angegeben werden.  Falls der hexadezimale
     Zeichenkode nur aus einer Hexadezimalziffer besteht, so muß eine
     führende Null hinzugefügt werden; ausgenommen, das kodierte
     Hexadezimalzeichen wird zuletzt in einer Einzelsequenz angegeben.

     Falls das Sequenzen-Trennzeichen, das `:' (Doppelpunkt) Zeichen
     selbst als Markierungszeichen benutzt werden soll, so muß dieses
     Zeichen entweder oktal `\072' oder hexadezimal `\x3A' kodiert
     werden.

     Falls das C Preprocessorsymbol USE_PAGER definiert wurde, und die
     Ausgabe des Programms redirektioniert wird oder in einer pipe
     steht, so werden Hervorhebungssequenzen automatisch in die
     entsprechenden Markierungszeichen umgesetzt; falls USE_PAGER nicht
     definiert wurde, so bleiben Hervorhebungssequenzen unverändert.

     Unvollständig oder garnicht angegebene Hervorhebungssequenzen
     werden durch intern fest voreingestellte ANSI
     Escape-Hervorhebungssequenzen ersetzt, falls eine `GCALANSI'
     Umgebungsvariable definiert ist; anderenfalls vollständig durch
     deren entsprechende Markierungszeichen ersetzt.  *Siehe GCALANSI:
     Umgebungsvariablen.

`-m ADRESSE'
`--mail=ADRESSE'
     Versenden von Gcal's Ausgabe via `mail' (3) Programm an die
     Email-Adresse ADRESSE, z.B.:

          --mail=root
          -m esken@uni-muenster.de

     Alle von Gcal selbst erzeugten Hervorhebungssequenzen werden beim
     Versenden einer Email stets unterdrückt bzw. automatisch in ihre
     entsprechenden Markierungszeichen umgesetzt, ganz gleich, ob die
     `--force-highlighting' Option angegeben wurde oder nicht.  Dieses
     Verhalten von Gcal ist deswegen zwingend erforderlich, da sonst
     das `mail' Programm den Versand der Post evtl. nicht korrekt
     vollziehen kann.  Beachten Sie bitte in diesem Zusammenhang auch
     die Hinweise hinsichtlich der Einschränkungen im Textteil einer
     Zeile der Ressourcendatei (*siehe Textteil einer Zeile::.).

  ---------- Fussnoten ----------

  (1)  Beachten Sie die Standard-Handbuchseiten zu `less', `more' und
`pg'.

  (2)  Beachten Sie die Standard-Handbuchseiten zu Termcap.

  (3)  Beachten Sie die Standard-Handbuchseiten zu `mail'.

Kalender Optionen
.................

`-n|N[-]'
`--holiday-list[=long|short]'
`--descending-holiday-list[=long|short]'
     Ausgabe der ewigen Feiertagsliste.  *Siehe Ewige Feiertage::, für
     zusätzliche Informationen.

    `-n'
    `--holiday-list=long'
          Aufsteigend sortierte Ausgabe der ewigen Feiertagsliste mit
          allen Feiertagen, d.h. den gesetzlichen Feiertagen und den
          Gedenktagen.

    `-n-'
    `--descending-holiday-list=long'
          Absteigend sortierte Ausgabe der ewigen Feiertagsliste mit
          allen Feiertagen, d.h. den gesetzlichen Feiertagen und den
          Gedenktagen.

    `-N'
    `--holiday-list=short'
          Aufsteigend sortierte Ausgabe der ewigen Feiertagsliste mit
          nur den gesetzlichen Feiertagen.

    `-N-'
    `--descending-holiday-list=short'
          Absteigend sortierte Ausgabe der ewigen Feiertagsliste mit
          nur den gesetzlichen Feiertagen.

`-X'
`--exclude-holiday-list-title'
     Ausgabe der Überschrift in der ewigen Feiertagsliste
     unterdrücken.

`--christan-holidays'
     Die ewige Feiertagsliste wird mit zusätzlichen christlichen
     Feiertagen ausgestattet.  Zudem werden auch in Kalenderblättern
     die Tage hervorgehoben, die durch diese Option in die ewige
     Feiertagsliste eingebracht und hervorgehoben werden.

`--de-holidays'
     Die ewige Feiertagsliste wird mit zusätzlichen deutschen
     Feiertagen ausgestattet.  Zudem werden auch in Kalenderblättern
     die Tage hervorgehoben, die durch diese Option in die ewige
     Feiertagsliste eingebracht und hervorgehoben werden.

`--us-holidays'
     Die ewige Feiertagsliste wird mit zusätzlichen US amerikanischen
     Feiertagen ausgestattet.  Zudem werden auch in Kalenderblättern
     die Tage hervorgehoben, die durch diese Option in die ewige
     Feiertagsliste eingebracht und hervorgehoben werden.

`-i[-]'
`--type=special|standard'
     Um das "Standard" Kalenderformat zu erhalten, so sollte Gcal
     entweder ganz ohne die `-i[-]' Option aufgerufen werden, da diese
     voreingestellt ist.  *Siehe Internationalisierung::, für weitere
     Details.  Oder aber um die Ausgabe eines Kalenderblatts zu
     erzwingen, sollte Gcal mit der `-i-' bzw. `--type=standard' Option
     aufgerufen werden:

          $ gcal -i-
          -|
          -| September 1994
          -|
          -| Montag           5 12 19 26
          -| Dienstag         6 13 20 27
          -| Mittwoch         7 14 21 28
          -| Donnerstag    1  8 15 22 29
          -| Freitag       2  9 16 23 30
          -| Samstag       3 10 17 24
          -| Sonntag       4 11 18 25

     Um das "Spezielle" Kalenderformat zu erhalten (ähnlich dem
     BSD-`cal' Programm), so sollte Gcal mit der Option `-i' bzw. mit
     der Option `--type=special' gestartet werden (auch hier wird die
     Ausgabe eine Kalenderblatts erzwungen):

          $ gcal -i
          -|
          -|    September 1994
          -| Mo Di Mi Do Fr Sa So
          -|           1  2  3  4
          -|  5  6  7  8  9 10 11
          -| 12 13 14 15 16 17 18
          -| 19 20 21 22 23 24 25
          -| 26 27 28 29 30

`-u'
`--suppress-calendar'
     Ausgabe eines Kalenderblatts explizit unterdrücken.

`-b ANZAHL'
`--blocks=ANZAHL'
     Setzen der ANZAHL von Blöcken, in der ein Jahreskalender
     ausgegeben wird (Zulässige Argumente: `1|2|3|4|6|12').  Die
     voreingestellte ANZAHL ist beim *Standard* Kalenderformat `-b 3'
     bzw. `--blocks=3', und beim *Speziellen* Kalenderformat `-b 4'
     bzw. `--blocks=4'.  Falls diese Option vorgefunden wird, so
     impliziert das Programm, daß die Ausgabe eines Jahreskalendes
     gewünscht wird!

    `-b 1'
    `--blocks=1'
          Gibt einen Block mit allen zwölf Monaten aus.

    `-b 2'
    `--blocks=2'
          Gibt zwei Blöcke mit je sechs Monaten aus.

    `-b 3'
    `--blocks=3'
          Gibt drei Blöcke mit je vier Monaten aus.

    `-b 4'
    `--blocks=4'
          Gibt vier Blöcke mit je drei Monaten aus.

    `-b 6'
    `--blocks=6'
          Gibt sechs Blöcke mit je zwei Monaten aus.

    `-b 12'
    `--blocks=12'
          Gibt zwölf Blöcke mit je einem Monat aus.

`-j[b]'
`--calendar-dates=special|both'
     Benutze alternatives Datumformat im Kalenderblatt anstelle des
     voreingestellten Standardformats, welches die laufenden Tage im
     Monat ausgibt.

    `-j'
    `--calendar-dates=special'
          Ausgabe des Kalenderblatts im speziellen Datumformat.
          Darunter ist zu verstehen, daß anstelle der Folge der
          Tagesnummern der Monate die Folge der Tagesnummern des Jahres
          ausgegeben wird.

    `-jb'
    `--calendar-dates=both'
          Ausgabe des Kalenderblatts im Standard- und speziellem
          Datumformat.

`-jn[b]'
`--holiday-dates=special|both'
     Benutze alternatives Datumformat in ewiger Feiertagsliste anstelle
     des voreingestellten Standardformats, welches die laufenden Tage
     im Monat ausgibt.  *Siehe `--holiday-list[=long|short]': Kalender
     Optionen.

    `-jn'
    `--holiday-dates=special'
          Ausgabe der ewige Feiertagsliste im speziellen Datumformat.
          Darunter ist zu verstehen, daß anstelle der Folge der
          Tagesnummern der Monate die Folge der Tagesnummern des Jahres
          ausgegeben wird.

    `-jnb'
    `--holiday-dates=both'
          Ausgabe der ewige Feiertagsliste im Standard- und speziellem
          Datumformat.

`-jc[b]'
`--fixed-dates=special|both'
     Benutze alternatives Datumformat in Terminwarnungsliste anstelle
     des voreingestellten Standardformats, welches die laufenden Tage
     im Monat ausgibt.  *Siehe `--list-of-fixed-dates[=short|long]':
     Terminwarnung Optionen.

    `-jc'
    `--fixed-dates=special'
          Ausgabe der Terminwarnungsliste im speziellen Datumformat.
          Darunter ist zu verstehen, daß anstelle der Folge der
          Tagesnummern der Monate die Folge der Tagesnummern des Jahres
          ausgegeben wird.

    `-jcb'
    `--fixed-dates=both'
          Ausgabe der Terminwarnungsliste im Standard- und speziellen
          Datumformat.

`-s ARGUMENT'
`--starting-day=ARGUMENT'
     Setzen des Starttags der Woche (Zulässiges ARGUMENT:
     `0, 1...7 | today | WOCHENTAGSNAME').

     Zum Beispiel:

          --starting-day=Sonntag oder
          --starting-day=7 oder
          -s SONNTAG oder
          -s sonnt oder
          -s So oder
          -s 7

     bezeichnet den Sonntag (1==Mo, 2==Di ... 7==So).

     Wenn die `-s today' Option (bzw. die `--starting-day=today') oder
     die `-s 0' Option (bzw. die `--starting-day=0') vorgefunden wird,
     so wird der Starttag der Woche auf den gerade aktuellen Wochentag
     gesetzt.

     *Siehe Internationalisierung::, für weitere Details.

`--gregorian-reform=1582|1752|ARGUMENT'
     Setzen des Zeitraums, der bei der Gregorianischen Reformation
     übergangen wurde.  *Siehe Internationalisierung::, für weitere
     Details.  Derzeit werden zwei fest vorgegebene Zeiträume
     (einerseits im Jahr 1582 und andererseits im Jahr 1752)
     unterstützt.  Wird Gcal mit der `--gregorian-reform=1582' Option
     aufgerufen, so wird angenommen, daß die Gregorianische
     Reformation vom 5'ten bis zum 14'ten Oktober 1582 stattgefunden
     hat.  Wird Gcal mit der `--gregorian-reform=1752' Option
     aufgerufen, so wird angenommen, daß die Gregorianische
     Reformation vom 3'ten bis zum 13'ten September 1752 stattgefunden
     hat.

     Soll ein anderer Zeitraum berücksichtigt werden, so kann dieser
     als Optionsargument ARGUMENT der Form `JJJJ,MM,STARTTAG,ENDETAG'
     vereinbart werden.  Wenn die Gregorianische Reformation zum
     Beispiel vom 7'ten bis zum 17'ten April 1802 stattgefunden hat, so
     kann das wie folgt deklariert werden:

          --gregorian-reform=1802,4,7,17

`--date-format=de|us|gb|TEXT'
     Setzen des Datumformats, welches die Anordnung und Darstellung von
     einem ausgegebenen Datum beeinflußt.  *Siehe
     Internationalisierung::, für weitere Details.  Der
     Datumformattext wird von Gcal in der ewigen Feiertagsliste, in der
     Terminwarnungsliste und in den Kalenderblättern berücksichtig;
     zudem versucht Gcal intern, stets die bestmöglichste Darstellung
     von einem ausgegebenen Datum zu erzielen wenn fortlaufende Tage
     des Jahres anstelle fortlaufender Tage des Monats ausgegeben
     werden sollen.

     Derzeit werden drei fest vorgegebene Datumformate (für deutsche
     Benutzer, US amerikanische Benutzer und Benutzer in
     Großbritannien) unterstützt.  Wird Gcal mit der
     `--date-format=de' Option aufgerufen, so wird der
     `%w,  %1%D%2 %b %y' Formattext benutzt.  Wird Gcal mit der
     `--date-format=us' Option aufgerufen, so wird der
     `%W, %b  %1%U%2 %y' Formattext benutzt.  Wird Gcal mit der
     `--date-format=gb' Option aufgerufen, so wird der
     `%W,  %1%U%2 %b %y' Formattext benutzt.

     Soll ein anderer Formattext berücksichtigt werden, so kann dieser
     entweder in der Umgebungsvariable `GCAL_DATE_FORMAT' angegeben
     werden (allerdings wird `GCAL_DATE_FORMAT' nur dann benutzt, wenn
     keine `--date-format=de|us|gb|TEXT' Option angegeben wird), oder
     aber als Optionsargument TEXT vereinbart werden, z.B.:

          --date-format="%Y %D %m ; %1(%A)%2"

     Der Formattext kann alle von Gcal ausgebbaren Zeichen enthalten,
     sowie Zeichenersatzangaben und Formatanweisungen, die zur Laufzeit
     in ihre entsprechenden Werte umgesetzt werden.  Ein minimaler
     Datumformattext muß Komponenten aus der Tag-Gruppe, der
     Monat-Gruppe, der Jahr-Gruppe und der Hervorhebung-Gruppe
     enthalten.  Eine Komponente aus der Wochentagsname-Gruppe ist
     optional.  Folgende Formatanweisungen und Zeichenersatzangaben
     werden derzeit unterstützt:

     Tag-Gruppe (genau ein Mitglied muß definiert werden):

    `%d'
          Tageszahl mit führenden Nullen

    `%D'
          Tageszahl mit führenden Leerzeichen

    `%u'
          Tageszahl mit führenden Nullen und nachfolgendem
          Ordnungszahlanhang

    `%U'
          Tageszahl mit führenden Leerzeichen und nachfolgendem
          Ordnungszahlanhang

     Monat-Gruppe (genau ein Mitglied muß definiert werden):

    `%B'
          Vollständiger Monatsname

    `%b'
          Abgekürzter Monatsname (3 Buchstaben)

    `%m'
          Monatszahl mit führenden Nullen

    `%M'
          Monatszahl mit führenden Leerzeichen

     Jahr-Gruppe (genau ein Mitglied muß definiert werden):

    `%y'
          Vollständige Jahreszahl mit führenden Nullen

    `%Y'
          Vollständige Jahreszahl mit führenden Leerzeichen

    `%z'
          Letzten zwei Ziffern der Jahreszahl mit führenden Nullen

    `%Y'
          Letzten zwei Ziffern der Jahreszahl mit führenden Leerzeichen

     Wochentagsname-Gruppe (ein Mitglied darf definiert werden):

    `%A'
          Vollständiger Wochentagsname

    `%W'
          Abgekürzter Wochentagsname (3 Buchstaben)

    `%w'
          Abgekürzter Wochentagsname (2 Buchstaben)

     Hervorhebung-Gruppe (alle Mitglieder müssen definiert werden, und
     `%1' muß vor `%2' angegeben werden):

    `%1'
          Start von Hervorhebungssequenz / Markierungszeichen

    `%2'
          Ende von Hervorhebungssequenz / Markierungszeichen

     Zeichenersatzangaben:

    `_'
          Leerzeichen ` '

    `\_'
          Unterstrichzeichen `_'

    `\%'
          Prozentzeichen `%'

Terminwarnung Optionen
......................

`-v ARGUMENT'
`--date-variable=ARGUMENT'
     Definiere "globale" Datumvariable, welche in allen referenzierten
     Ressourcendateien sichtbar ist (*siehe Datumvariablen::.).  Das
     Optionsargument ARGUMENT muß entweder eine einzelne
     Datumvariablen-Definition oder eine durch `:' Doppelpunkt
     voneinander getrennte Liste von Definitionen sein.

     Der Name einer Datumvariablen DVAR besteht aus einem einzelnen
     Buchstaben (Groß- bzw. Kleinbuchstaben werden nicht unterschieden
     und ausgenommen dem Buchstaben `e', welcher intern für das Datum
     des Ostersonntags reserviert ist und welcher deswegen nicht
     zuweisbar/inoperabel ist), und wird bei einer Definition gefolgt
     von dem Zuweisungsoperator `=' und den Zahlenwerten für Monat MM
     (oder einem Monatsnamen im dreistelligen Kurzformat, z.B.  `Jan',
     `Feb', ...) und Tag TT, welche diese Variable aufzunehmen hat
     (oder dem Namen einer anderen globalen Datumvariablen, aber nicht
     einer Datumangabe im `MMWWWN', `DVAR[+|-]N[WWW]' oder `*d|wN[WWW]'
     Format).

     Einige Beispiele:

          `--date-variable=a=1127:c=a' bzw.
          `-v a=1127:c=a'
          speichert den 27'ten November in der globalen Datumvariablen A
          und in der globalen Datumvariablen C.

`--export-date-variables'
     Bewirkt den Export lokaler Datumvariablen von Ressourcendatei zu
     Ressourcendatei.  *Siehe Datumvariablen::, für weitere Details.

`-r ARGUMENT'
`--text-variable=ARGUMENT'
     Definiere "globale" Textvariable, welche in allen referenzierten
     Ressourcendateien sichtbar ist (*siehe Textvariablen::.).  Das
     Optionsargument ARGUMENT muß entweder eine einzelne
     Textvariablen-Definition oder eine durch `:' Doppelpunkt
     voneinander getrennte Liste von Definitionen sein.

     Der Name einer Textvariablen TVAR besteht aus einem `$' Präfix
     und einem einzelnen Buchstaben (Groß- bzw. Kleinbuchstaben werden
     nicht unterschieden), und wird bei einer Definition gefolgt von
     dem Zuweisungsoperator `=' und dem Text, welchen diese Variable
     aufzunehmen hat.  Eine globale Textvariable wird mit *leerem*
     Inhalt definiert falls kein Text rechts des Zuweisungsoperators
     angegeben ist.

     Einige Beispiele:

          `--text-variable=$a=foo:$c=$a' bzw.
          `-r $a=foo:$c=$a'
          speichert den Text `foo' in der globalen Textvariablen $A und
          in der globalen Textvariablen $C.

     Falls das `:' Zeichen im Text als Zeichen selbst verwendet werden
     soll, so muß dieses durch ein führendes `\' (Backslash) Zeichen
     quotiert (geschützt/entwertet) werden, z.B. `\:'.

     Wenn die Zeichen `\:' im Text selbst als Zeichenfolge verwendet
     werden sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\:'.

     Falls das `$' Zeichen im Text als Zeichen selbst verwendet werden
     soll, so muß dieses durch ein führendes `\' (Backslash) Zeichen
     quotiert (geschützt/entwertet) werden, z.B. `\$'.

     Wenn die Zeichen `\$' im Text selbst als Zeichenfolge verwendet
     werden sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\$'.

     Jedesmal wenn ein `_' (Unterstrich) Zeichen in ARGUMENT vorgefunden
     wird, so wird dieses Zeichen durch ein echtes ` ' (Leerzeichen)
     Zeichen ersetzt.

     Falls das `_' (Unterstrich) Zeichen als Zeichen selbst verwendet
     werden soll, so muß dieses durch ein führendes `\' (Backslash)
     Zeichen quotiert (geschützt/entwertet) werden, z.B. `\_'.

     Wenn die Zeichen `\_' selbst als Zeichenfolge verwendet werden
     sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\_'.

`--export-text-variables'
     Bewirkt den Export lokaler Textvariablen von Ressourcendatei zu
     Ressourcendatei.  *Siehe Textvariablen::, für weitere Details.

`-c|C[-]'
`--today'
`--list-of-fixed-dates[=short|long]'
`--descending-fixed-dates[=short|long]'
     Aktivierung der Terminwarnungsfunktion und Ausgabe von
     Terminwarnungen.

    `-c'
    `--today'
    `--list-of-fixed-dates=short'
          Aktivierung der Terminwarnungsfunktion (implizite Benutzung
          der Standard-Ressourcendatei) und alle Daten in aufsteigender
          Reihenfolge ausgeben, die sich auf den heutigen Tag beziehen.
          Wenn keine Daten zum heutigen Tag vorgefunden werden, so
          werden keine Terminwarnungen ausgegeben und das Programm wird
          mit Fehlerkode abgebrochen; siehe auch *Siehe 1: Fehlerkodes.

    `-c-'
    `--descending-fixed-dates=short'
          Aktivierung der Terminwarnungsfunktion (implizite Benutzung
          der Standard-Ressourcendatei) und alle Daten in absteigender
          Reihenfolge ausgeben, die sich auf den heutigen Tag beziehen.
          Wenn keine Daten zum heutigen Tag vorgefunden werden, so
          werden keine Terminwarnungen ausgegeben und das Programm wird
          mit Fehlerkode abgebrochen; siehe auch *Siehe 1: Fehlerkodes.

    `-C'
    `--list-of-fixed-dates=long'
          Aktivierung der Terminwarnungsfunktion (implizite Benutzung
          der Standard-Ressourcendatei) und alle Daten in aufsteigender
          Reihenfolge ausgeben, die sich auf den heutigen Tag beziehen.
          Wenn keine Daten zum heutigen Tag vorgefunden werden, so
          wird eine nur aus dem Datum bestehende Terminwarnung
          ausgegeben.

    `-C-'
    `--descending-fixed-dates=long'
          Aktivierung der Terminwarnungsfunktion (implizite Benutzung
          der Standard-Ressourcendatei) und alle Daten in absteigender
          Reihenfolge ausgeben, die sich auf den heutigen Tag beziehen.
          Wenn keine Daten zum heutigen Tag vorgefunden werden, so
          wird eine nur aus dem Datum bestehende Terminwarnung
          ausgegeben.

`-f|F DATEINAME[+...]'
`--resource-file=DATEINAME'
     Aktivierung der Terminwarnungsfunktion und Datei DATEINAME
     anstelle der Standard-Ressourcendatei benutzen.  Sodann alle Daten
     in aufsteigender Reihenfolge ausgeben, die in den
     Terminwarnungszeitraum fallen.  Wurde kein besonderer
     Terminwarnungszeitraum angegeben, so wird der heutige Tag als
     Terminwarnungszeitraum angenommen.  Wurde der Optionsbuchstabe `f'
     bei der Kurzoption benutzt und es werden keine Daten in DATEINAME
     vorgefunden, die in den Terminwarnungszeitraum fallen, so werden
     keine Terminwarnungen ausgegeben und das Programm wird mit
     Fehlerkode abgebrochen; siehe auch *Siehe 1: Fehlerkodes.  Wurde
     der Optionsbuchstabe `F' bei der Kurzoption benutzt und es werden
     keine Daten in DATEINAME vorgefunden, die in den
     Terminwarnungszeitraum fallen, so wird eine nur aus dem Datum
     bestehende Terminwarnung ausgegeben.

     Es kann mehr als eine Ressourcendatei DATEINAME verwendet werden,
     wenn die zusätzlichen Ressourcendateien, durch ein `+' Zeichen
     getrennt, aufgeführt werden, z.B.:

          `--resource-file=./foo+xyz+/data/foo.bar+$HOME/.gcalrc' bzw.
          `-f ./foo+xyz+/data/foo.bar+$HOME/.gcalrc'

     berücksichtigt alle Dateien, die in dem vorstehenden Argument
     aufgeführt sind; dabei wird ein spezieller Suchmechanismus zum
     Auffinden der Dateien benutzt.  *Siehe Datei-Suchmechanismus:
     Ressourcendatei, für weitere Details.  Wenn DATEINAME auf
     `/dev/null' gesetzt ist, so wird daß Vorladen einer
     Standard-Ressourcendatei verhindert, was nützlich ist, wenn leere
     Terminwarnungslisten erzeugt werden sollen.

     Falls das `+' Zeichen als Zeichen selbst verwendet werden soll, so
     muß dieses durch ein führendes `\' (Backslash) Zeichen quotiert
     (geschützt/entwertet) werden, z.B. `\+'.

     Wenn die Zeichen `\+' selbst als Zeichenfolge verwendet werden
     sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\+'.

     Jedesmal wenn ein `_' (Unterstrich) Zeichen in DATEINAME
     vorgefunden wird, so wird dieses Zeichen durch ein echtes ` '
     (Leerzeichen) Zeichen ersetzt.

     Falls das `_' (Unterstrich) Zeichen als Zeichen selbst verwendet
     werden soll, so muß dieses durch ein führendes `\' (Backslash)
     Zeichen quotiert (geschützt/entwertet) werden, z.B. `\_'.

     Wenn die Zeichen `\_' selbst als Zeichenfolge verwendet werden
     sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\_'.

*Bitte beachten:*
Wenn die Kurzoption `-c' und/oder ihre Modifizierer `t|[w|m|y[+|-]'
bzw. die Kurzoption `-f' in *Großbuchstaben* angegeben werden, z.B.:

     -C
     -F foo.bar
     -CeT
     -c-aW+
     -CeaxY-
     -c-M

so gibt Gcal für *jeden* Tag in der verlangten Periode Terminwarnungen
aus.

Die Modifizierer einer kombinierten/komplexen/gepackten Kurzoption zur
Terminwarnung müssen entsprechend der hier vorgegebenen Reihenfolge
zusammengesetzt werden, da Gcal diese als positionale Parameter
behandelt:

    Erste Stufe: *Repräsentation-des-Textes*
          `a', `A', `e|E', `k', `o', `x', `z'

    Zweite Stufe: *Setzung-der-uu-berücksichtigenden-Periode*
          `d', `l', `t|T', `w|W|m|M|y|Y[+|-]', `N+|-', `Nd', `Nw',
          `*dN[WWW]', `*wN[WWW]', `@e|DVAR[[+|-]N]', `@e|DVAR[+|-]NWWW',
          `MMTT', `MMWWWN'

Wenn mit den folgenden Modifizierern gearbeitet werden möchte, so
*muß* eine explizite `-c|C[-]' Kurzoption zuvor angegeben sein, z.B.:

     -c-t
     -cw-
     -CaAdeklorxz12+

und es darf nur *ein* zeitraumdefinierender
Terminwarnungszeitraum-Modifizierer angegeben werden (davon ausgenommen
sind die `--include-today' Option bzw.  der `d' Modifizierer, die
`--list-mode' Option bzw. der `l' Modifizierer und die
`--leap-day=february|march' Option).

Oder die Modifizierer müssen als Einzelzeichenoption oder
zusammengefasst zu einem einzelnen Kommandozeilenwort angegeben werden,
und es muß zudem entweder die Kurzoption `-c|C[-]' (oder die
entsprechende Langoption) bzw. `-f|F DATEINAME[+...]' (oder die
entsprechende Langoption) angegeben werden, z.B.:

     -c- -t
     -w- -c
     -a -Ad -e -klorxz -C12+
     -F foo.bar -Ad -l*d10

Werden Modifizierer als Einzelzeichenoption oder zu einem einzelnen
Kommandozeilenwort zusammengefasst angegeben und dabei einer der
`t|T|[w|W|m|M|y|Y[+|-]]' Modifizierer benutzt (oder deren entsprechende
Aliasnamen wie `--today', `--tomorrow'...), so ist die Angabe einer
`-c|C[-]' Kurzoption (oder deren entsprechende Langoption) bzw.
`-f|F DATEINAME[+...]' Kurzoption (oder deren entsprechende Langoption)
nicht notwendig um die Terminwarnungsfunktion von Gcal zu aktivieren,
da die Terminwarnungsfunktion durch diese Modifizierer implizit
ausgelöst wird.

*Terminwarnungstext-Modifizierer:*

`a'
`--include-resource-file-name'
     Den Namen der verwendeten Ressourcendatei in der Terminwarnung
     zusätzlich mit ausgeben, z.B.:

          Mo,   1 Jan 1995: (`Ewige Feiertagsliste') Neujahr
          Mo,   1 Jan 1995: (.gcalrc) Keine weiteren Termine
          ...

`A'
`--alternative-format'
     Anstelle der Ausgabe im "Standard" Listenformat, z.B.:

          Mo,   1 Jan 1995: Neujahr
          Mo,   1 Jan 1995: Keine weiteren Termine
          ...

     benutzt Gcal das "Alternative" Listenformat, z.B.:

          Mo,   1 Jan 1995:
          Neujahr
          Keine weiteren Termine
          ...

`e'
`--include-holidays=long'
     Alle Daten aus der eingebauten ewigen Feiertagsliste in die
     Terminwarnungsliste einstreuen, d.h. gesetzliche Feiertage und
     Gedenktage.

`E'
`--include-holidays=short'
     Nur diejenigen Daten aus der eingebauten ewigen Feiertagsliste in
     die Terminwarnungsliste einstreuen, die gesetzliche Feiertage sind.

`g[TEXT]'
`--grouping-text[=TEXT]'
     Gruppiere die Terminwarnungen tageweise mittels des Separators
     TEXT.  Wenn kein TEXT angegeben ist, so wird der eingebaute TEXT
     (`RC_GROUP_SEP' "" == nur Leerzeile) zum Gruppieren verwendet,
     z.B.:

          $ gcal -Cw -cg
          -|
          -| So,   6 Nov 1994: Text 1
          -| So,   6 Nov 1994: Text 2
          -|
          -| Mo,   7 Nov 1994: Text 3
          -|
          -| Di,   8 Nov 1994: Text 4
          ...
          
          
          $ gcal -Cw -g'-Ein_vom\_Benutzer-~-definierter Text-'
          -|
          -| So,   6 Nov 1994: Text 1
          -| So,   6 Nov 1994: Text 2
          -| -Ein vom_Benutzer-
          -| -definierter Text-
          -| Mo,   7 Nov 1994: Text 3
          -| -Ein vom_Benutzer-
          -| -definierter Text-
          -| Di,   8 Nov 1994: Text 4
          ...

     Jedesmal wenn ein `~' (Tilde) Zeichen in TEXT vorgefunden wird, so
     wird dieses Zeichen durch ein echtes `\n' (Newline) Zeichen
     ersetzt.

     Falls das `~' (Tilde) Zeichen als Zeichen selbst verwendet werden
     soll, so muß dieses durch ein führendes `\' (Backslash) Zeichen
     quotiert (geschützt/entwertet) werden, z.B. `\~'.

     Wenn die Zeichen `\~' selbst als Zeichenfolge verwendet werden
     sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\~'.

     Jedesmal wenn ein `_' (Unterstrich) Zeichen in TEXT vorgefunden
     wird, so wird dieses Zeichen durch ein echtes ` ' (Leerzeichen)
     Zeichen ersetzt.

     Falls das `_' (Unterstrich) Zeichen als Zeichen selbst verwendet
     werden soll, so muß dieses durch ein führendes `\' (Backslash)
     Zeichen quotiert (geschützt/entwertet) werden, z.B. `\_'.

     Wenn die Zeichen `\_' selbst als Zeichenfolge verwendet werden
     sollen, so muß das `\' (Backslash) Zeichen mit sich selbst
     quotiert werden, z.B. `\\_'.

`k'
`--include-weeknumber'
     Das führende Datum in einem Terminwarnungstext wird bei Ausgabe
     mit der ISO-8601:1988 Wochennummer von diesem Datum versehen.

     *Bitte beachten:*
     Die Methoden der ISO-8601:1988 werden zur Ermittlung der
     Wochennummern verwendet.  Das bedeutet, daß eine Woche mit einem
     Montag beginnt, und die erste Woche des Jahres ist diejenige
     Woche, in welche der erste Donnerstag fällt, also gleich der
     Woche ist, in welcher der 4'te Januar auftritt.

`o'
`--omit-multiple-date-part'
     Vermeidet die Mehrfachausgabe von einem jede Einzelzeile
     anführendem Datum in der Terminwarnungsliste, falls sich weitere
     Termine auf dieses Datum beziehen (nur falls die
     `--alternative-format' Option bzw. der `A' Modifizierer nicht
     angegeben wurde), z.B.:

          $ gcal -co
          -|
          -| So,   6 Nov 1994: Text 1
          -|                   Text 2
          ...

`x'
`--exclude-fixed-dates-list-title'
     Ausgabe der Überschrift in der Terminwarnungsliste unterdrücken.

`z'
`--include-consecutive-number'
     Laufende Postennummer der Terminwarnung ausgeben.

*Terminwarnungszeitraum-Modifizierer:*

`--leap-day=february|march'
     Den "Schalttag" (d.h. den 29'ten Februar) auch in
     Nicht-Schaltjahren berücksichtigen.

    `--leap-day=february'
          Eine Terminwarnung, die in jedem Jahr gelten soll und sich
          auf den Schalttag bezieht, wird in Nicht-Schaltjahren am
          28'ten Februar ausgegeben.

    `--leap-day=march'
          Eine Terminwarnung, die in jedem Jahr gelten soll und sich
          auf den Schalttag bezieht, wird in Nicht-Schaltjahren am
          1'ten März ausgegeben.

`d'
`--include-today'
     Wenn eine Datumliste erzeugt wird, so wird das aktuelle Datum in
     dieser Liste mit eingeschlossen.  *Siehe `--list-mode':
     Terminwarnung Optionen, wie eine Datumliste erzeugt wird.

`l'
`--list-mode'
     Erzeugen einer Datumliste anstelle eines Einzeldatum.

     *Bitte beachten:*
     In den folgenden Beispielen wird angenommen, daß das heutige
     Tagesdatum der 17'te Februar eines beliebigen Jahres ist!

`--period-of-fixed-dates=ARGUMENT'
`Nd'
`*dN'
     Alle Daten zum absoluten Tag N == `1...365|366|999' im aktuellen
     Jahr ausgeben; das Warnungsniveau ist wie bei der einfachen `-c'
     Option.  Wenn für N der Wert 999 angegeben ist, so wird der
     letzte Tag im Jahr (31'ter Dezember) angenommen.

        * Z.B. `gcal -c10d' bzw. `gcal --period-of-fixed-dates=10d'
          oder `gcal -c*d10' bzw. `gcal --period-of-fixed-dates=*d10'
          gibt die Termine aus, die am 10'ten Tag des Jahres
          stattfinden.

`lNd'
`l*dN'
     Liste von Daten, in Abhängigkeit des Wertes von N gestern oder
     morgen beginnend, und endend am N'ten absoluten Tag des aktuellen
     Jahres; das Warnungsniveau ist wie bei der `-cy' Option.

        * Z.B. `gcal -cl10d' bzw. `gcal -cl*d10' gibt eine Liste aller
          derjenigen Termine aus, die am 10'ten Tag des Jahres beginnen
          und am 16'ten Februar enden.

`N+|-'
     Alle Daten zum Tag *heute `+/-' N Tage* im aktuellen Jahr
     ausgeben; das Warnungsniveau ist wie bei der einfachen `-c' Option.

        * Z.B. `gcal -c10+' gibt die Termine aus, die 10 Tage nach dem
          17'ten Februar (heute) stattfinden.

        * Z.B. `gcal -c10-' gibt die Termine aus, die 10 Tage vor dem
          17'ten Februar (heute) stattfinden.

`lN+|-'
     Liste von Daten, gestern `-' oder morgen `+' beginnend, und endend
     am Tag *heute `+/-' N Tage* im aktuellen Jahr ausgeben; das
     Warnungsniveau ist wie bei der `-cy' Option.

        * Z.B. `gcal -cl10+' gibt eine Liste aller derjenigen Termine
          aus, die am 18'ten Februar beginnen und 10 Tage danach enden.

        * Z.B. `gcal -cl10-' gibt eine Liste aller derjenigen Termine
          aus, die 10 Tage vor dem 16'ten Februar beginnen und am
          16'ten Februar enden.

`Nw'
     Alle Daten zur Woche Nummer N == `0|1...52|53|99' des aktuellen
     Jahres ausgeben; das Warnungsniveau ist wie bei der `-cw' Option.

        * Z.B. `gcal -c0w' gibt alle diejenigen Termine aus, die falls
          das Vorjahr eine 53'te ISO-Kalenderwoche hat, in der 53'ten
          ISO-Kalenderwoche des Vorjahres liegen oder falls das Vorjahr
          keine 53'te ISO-Kalenderwoche hat, in der 1'ten
          ISO-Kalenderwoche des aktuellen Jahres liegen.

        * Z.B. `gcal -c6w' gibt alle diejenigen Termine aus, die in der
          6'ten ISO-Kalenderwoche liegen.

        * Z.B. `gcal -c52w' gibt alle diejenigen Termine aus, die in
          der 52'ten ISO-Kalenderwoche liegen.

        * Z.B. `gcal -c53w' gibt alle diejenigen Termine aus, die in
          der 53'ten ISO-Kalenderwoche liegen, falls das Jahr eine 53'te
          ISO-Kalenderwoche hat.  Wenn das Jahr keine 53'te
          ISO-Kalenderwoche hat, so werden keine Terminwarnungen
          ausgegeben und das Programm wird mit Fehlerkode abgebrochen;
          siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -c99w' gibt alle diejenigen Termine aus, die in
          der letzten ISO-Kalenderwoche liegen, d.h. entweder die 52'te
          oder die 53'te ISO-Kalenderwoche.

`lNw'
     Liste von Daten, in Abhängigkeit der gegebenen Wochennummer
     N == `0|1...52|53|99' gestern oder morgen beginnend und endend am
     ersten bzw. letzten Tag der gegebenen Woche N des aktuellen Jahres
     ausgeben; das Warnungsniveau ist wie bei der `-cy' Option.

        * Z.B. `gcal -cl12w' gibt eine Liste aller derjenigen Termine
          aus, die am 18'ten Februar beginnen und bis zum Ende der
          12'ten ISO-Kalenderwoche reichen.

        * Z.B. `gcal -cl3w' gibt eine Liste aller derjenigen Termine
          aus, die am Anfang der 3'ten ISO-Kalenderwoche beginnen und
          16'ten Februar enden.

`MMTT'
     Alle Daten zum Tag TT im Monat MM des aktuellen Jahres ausgeben;
     das Warnungsniveau ist wie bei der einfachen `-c' Option.

        * Z.B. `gcal -c0225' gibt die Termine aus, die am 25'ten
          Februar stattfinden.

`lMMTT'
     Liste von Daten, in Abhängigkeit des Wertes MMTT gestern bzw.
     morgen beginnend, und endend am Tag TT im Monat MM des aktuellen
     Jahres, ausgeben; das Warnungsniveau ist wie bei der `-cy' Option.

        * Z.B. `gcal -cl0225' gibt eine Liste aller derjenigen Termine
          aus, die am 18'ten Februar beginnen und am 25'ten Februar
          enden.

        * Z.B. `gcal -cl0109' gibt eine Liste aller derjenigen Termine
          aus, die am 9'ten Januar beginnen und am 16'ten Februar enden.

`MMWWWN'
     Alle Daten zum N'ten == `1...5|9' Wochentag WWW im Monat MM des
     aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     einfachen `-c' Option.

        * Z.B. `gcal -c01mon3' gibt die Termine aus, die am dritten
          Montag im Januar stattfinden.

        * Z.B. `gcal -c02fr9' gibt die Termine aus, die am letzten
          Freitag im Februar stattfinden.

`lMMWWWN'
     Liste von Daten, in Abhängigkeit des Wertes in MMWWWN gestern
     bzw. morgen beginnend, und endend am N'ten == `1...5|9' Wochentag
     WWW im Monat MM des aktuellen Jahres ausgeben; das Warnungsniveau
     ist wie bei der `-cy' Option.

        * Z.B. `gcal -cl01mon3' gibt eine Liste aller derjenigen
          Termine aus, die am dritten Montag im Januar beginnen und am
          16'ten Februar enden.

        * Z.B. `gcal -cl02fr9' gibt eine Liste aller derjenigen Termine
          aus, die am 18'ten Februar beginnen und am letzten Freitag im
          Februar enden.

`*dNWWW'
     Alle Daten zum N'ten == `1...51|52|53|99' Wochentag WWW des
     aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     einfachen `-c' Option.

        * Z.B. `gcal -c*d16son' gibt alle diejenigen Termine aus, die
          auf den 16'ten Sonntag des Jahres fallen.

        * Z.B. `gcal -c*d52son' gibt alle diejenigen Termine aus, die
          auf den 52'ten Sonntag des Jahres fallen.  Wenn das Jahr
          keinen 52'ten Sonntag hat, so werden keine Terminwarnungen
          ausgegeben und das Programm wird mit Fehlerkode abgebrochen;
          siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -c*d53son' gibt alle diejenigen Termine aus, die
          auf den 53'ten Sonntag des Jahres fallen.  Wenn das Jahr
          keinen 53'ten Sonntag hat, so werden keine Terminwarnungen
          ausgegeben und das Programm wird mit Fehlerkode abgebrochen;
          siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -c*d99son' gibt alle diejenigen Termine aus, die
          auf den letzten Sonntag (das ist entweder der 51'te, 52'te
          oder 53'te Sonntag) des Jahres fallen.

`l*dNWWW'
     Liste von Daten, in Abhängigkeit des Wertes N gestern oder morgen
     beginnend, und endend am N'ten == `1...51|52|53|99' Wochentag WWW
     des aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     `-cy' Option.

        * Z.B. `gcal -cl*d16son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am 16'ten
          Sonntag des Jahres enden.

        * Z.B. `gcal -cl*d52son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am 52'ten
          Sonntag des Jahres enden.  Wenn das Jahr keinen 52'ten
          Sonntag hat, so werden keine Terminwarnungen ausgegeben und
          das Programm wird mit Fehlerkode abgebrochen; siehe auch
          *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -cl*d53son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am 53'ten
          Sonntag des Jahres enden.  Wenn das Jahr keinen 53'ten
          Sonntag hat, so werden keine Terminwarnungen ausgegeben und
          das Programm wird mit Fehlerkode abgebrochen; siehe auch
          *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -cl*d99son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am letzten
          Sonntag (das ist entweder der 51'te, 52'te oder 53'te
          Sonntag) des Jahres enden.

`*wN[WWW]'
     Alle Daten zum Wochentag WWW der N'ten == `0|1...52|53|99'
     ISO-Kalenderwoche des aktuellen Jahres ausgeben; das
     Warnungsniveau ist wie bei der einfachen `-c' Option.  Wenn kein
     Wochentag WWW angegeben ist, so wird Montag als Wochentag
     angenommen.

        * Z.B. `gcal -c*w0son' gibt alle diejenigen Termine aus, die
          falls das Jahr einen Sonntag hat, der in der 52'ten bzw.
          53'ten ISO-Kalenderwoche des Vorjahres liegt, auf diesen
          Sonntag fallen.  Wenn ein solcher Sonntag nicht existiert, so
          werden keine Terminwarnungen ausgegeben und das Programm wird
          mit Fehlerkode abgebrochen; siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -c*w16son' gibt alle diejenigen Termine aus, die
          auf den Sonntag der 16'ten ISO-Kalenderwoche des Jahres
          fallen.

        * Z.B. `gcal -c*w52son' gibt alle diejenigen Termine aus, die
          auf den Sonntag der 52'ten ISO-Kalenderwoche des Jahres
          fallen.  Wenn das Jahr keinen Sonntag der 52'ten
          ISO-Kalenderwoche hat, so werden keine Terminwarnungen
          ausgegeben und das Programm wird mit Fehlerkode abgebrochen;
          siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -c*w53son' gibt alle diejenigen Termine aus, die
          auf den Sonntag der 53'ten ISO-Kalenderwoche des Jahres
          fallen.  Wenn das Jahr keinen Sonntag der 53'ten
          ISO-Kalenderwoche hat, so werden keine Terminwarnungen
          ausgegeben und das Programm wird mit Fehlerkode abgebrochen;
          siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -c*w99son' gibt alle diejenigen Termine aus, die
          auf den Sonntag der letzten ISO-Kalenderwoche (das ist
          entweder die 51'te, 52'te oder 53'te ISO-Kalenderwoche) des
          Jahres fallen.

`l*wN[WWW]'
     Liste von Daten, in Abhängigkeit des Wertes N gestern oder morgen
     beginnend, und endend am Wochentag WWW der
     N'ten == `1...51|52|53|99' ISO-Kalenderwoche des aktuellen Jahres
     ausgeben; das Warnungsniveau ist wie bei der `-cy' Option.  Wenn
     kein Wochentag WWW angegeben ist, so wird Montag als Wochentag
     angenommen.

        * Z.B. `gcal -cl*w0son' gibt eine Liste aller derjenigen
          Termine aus, die falls das Jahr einen Sonntag hat, der in der
          52'ten bzw. 53'ten ISO-Kalenderwoche des Vorjahres liegt, an
          diesem Sonntag beginnen und am 16'ten Februar enden.  Wenn
          ein solcher Sonntag nicht existiert, so werden keine
          Terminwarnungen ausgegeben und das Programm wird mit
          Fehlerkode abgebrochen; siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -cl*w16son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am Sonntag
          der 16'ten ISO-Kalenderwoche des Jahres enden.

        * Z.B. `gcal -cl*w52son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am Sonntag
          der 52'ten ISO-Kalenderwoche des Jahres enden.  Wenn das Jahr
          keinen Sonntag der 52'ten ISO-Kalenderwoche hat, so werden
          keine Terminwarnungen ausgegeben und das Programm wird mit
          Fehlerkode abgebrochen; siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -cl*w53son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am Sonntag
          der 53'ten ISO-Kalenderwoche des Jahres enden.  Wenn das Jahr
          keinen Sonntag der 53'ten ISO-Kalenderwoche hat, so werden
          keine Terminwarnungen ausgegeben und das Programm wird mit
          Fehlerkode abgebrochen; siehe auch *Siehe 126: Fehlerkodes.

        * Z.B. `gcal -cl*w99son' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am Sonntag
          der letzten ISO-Kalenderwoche (das ist entweder der 51'te,
          52'te oder 53'te ISO-Kalenderwoche) des Jahres enden.

`@e[[+|-]N]'
     Alle Daten zum N'ten Tag relativ zum Datum Ostersonntag des
     aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     einfachen `-c' Option.

        * Z.B. `gcal -c@e' gibt die Termine aus, die am Ostersonntag
          stattfinden.

        * Z.B. `gcal -c@e10' bzw. `gcal -c@e+10' gibt die Termine aus,
          die 10 Tage nach Ostersonntag stattfinden.

        * Z.B. `gcal -c@e-10' gibt die Termine aus, die 10 Tage vor
          Ostersonntag stattfinden.

`l@e[[+|-]N]'
     Liste von Daten, in Abhängigkeit des Wertes N gestern oder morgen
     beginnend, und endend am N'ten Tag relativ zum Datum Ostersonntag
     des aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     `-cy' Option.

        * Z.B. `gcal -cl@e' gibt eine Liste aller derjenigen Termine
          aus, die am 18'ten Februar beginnen und am Ostersonntag enden.

        * Z.B. `gcal -cl@e10' bzw. `gcal -cl@e+10' gibt eine Liste aller
          derjenigen Termine aus, die am 18'ten Februar beginnen und 10
          Tage nach Ostersonntag enden.

        * Z.B. `gcal -cl@e-10' gibt eine Liste aller derjenigen Termine
          aus, die am 18'ten Februar beginnen und 10 Tage vor
          Ostersonntag enden.

`@e[+|-]NWWW'
     Alle Daten zum N'ten Wochentag WWW relativ zum Datum Ostersonntag
     des aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     einfachen `-c' Option.

        * Z.B. `gcal -c@e3fr' bzw. `gcal -c@e+3fr' gibt die Termine aus,
          die am 3'ten Freitag nach Ostersonntag stattfinden.

        * Z.B. `gcal -c@e-3fr' gibt die Termine aus, die am 3'ten
          Freitag vor Ostersonntag stattfinden.

`l@e[+|-]NWWW'
     Liste von Daten, in Abhängigkeit des Wertes N gestern oder morgen
     beginnend, und endend am N'ten Wochentag WWW relativ zum Datum
     Ostersonntag des aktuellen Jahres ausgeben; das Warnungsniveau ist
     wie bei der `-cy' Option.

        * Z.B. `gcal -cl@e3fr' bzw. `gcal -cl@e+3fr' gibt eine Liste
          aller derjenigen Termine aus, die am 18'ten Februar beginnen
          und am 3'ten Freitag nach Ostersonntag enden.

        * Z.B. `gcal -cl@e-3fr' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am 3'ten
          Freitag vor Ostersonntag enden.

`@DVAR[[+|-]N]'
     Alle Daten zum N'ten Tag relativ zum Datum der Datumvariablen des
     aktuellen Jahres ausgeben; das Warnungsniveau ist wie bei der
     einfachen `-c' Option.

        * Z.B. `gcal -v a=0422 -c@a' gibt die Termine aus, die am
          22'ten April stattfinden.

        * Z.B. `gcal -v a=0422 -c@a10' bzw. `gcal -v a=0422 -c@a+10'
          gibt die Termine aus, die 10 Tage nach dem 22'ten April
          stattfinden.

        * Z.B. `gcal -v a=0422 -c@a-10' gibt die Termine aus, die 10
          Tage vor dem 22'ten April stattfinden.

`l@DVAR[[+|-]N]'
     Liste von Daten, in Abhängigkeit des Wertes N gestern oder morgen
     beginnend, und endend am N'ten Tag relativ zum Datum der
     Datumvariablen des aktuellen Jahres ausgeben; das Warnungsniveau
     ist wie bei der `-cy' Option.

        * Z.B. `gcal -v a=0422 -cl@a' gibt eine Liste aller derjenigen
          Termine aus, die am 18'ten Februar beginnen und am 22'ten
          April enden.

        * Z.B. `gcal -v a=0422 -cl@a10' bzw. `gcal -v a=0422 -cl@a+10'
          gibt eine Liste aller derjenigen Termine aus, die am 18'ten
          Februar beginnen und 10 Tage nach dem 22'ten April enden.

        * Z.B. `gcal -v a=0422 -cl@a-10' gibt eine Liste aller
          derjenigen Termine aus, die am 18'ten Februar beginnen und 10
          Tage vor dem 22'ten April enden.

`@DVAR[+|-]NWWW'
     Alle Daten zum N'ten Wochentag WWW relativ zum Datum der
     Datumvariablen des aktuellen Jahres ausgeben; das Warnungsniveau
     ist wie bei der einfachen `-c' Option.

        * Z.B. `gcal -v a=0122 -c@a2sa' bzw. `gcal -v a=0122 -c@a+2sa'
          gibt die Termine aus, die zwei Samstage nach dem 22'ten
          Januar stattfinden.

        * Z.B. `gcal -v a=0122 -c@a-2sa' gibt die Termine aus, die zwei
          Samstage vor dem 22'ten Januar stattfinden.

`l@DVAR[+|-]NWWW'
     Liste von Daten, in Abhängigkeit des Wertes N gestern oder morgen
     beginnend, und endend am N'ten Wochentag WWW relativ zum Datum der
     Datumvariablen des aktuellen Jahres ausgeben; das Warnungsniveau
     ist wie bei der `-cy' Option.

        * Z.B. `gcal -v a=0122 -cl@a2sa' bzw. `gcal -v a=0122 -cl@a+2sa'
          gibt eine Liste aller derjenigen Termine aus, die zwei
          Samstage nach dem 22'ten Januar beginnen und am 16'ten
          Februar enden.

        * Z.B. `gcal -v a=0122 -cl@a-2sa' gibt eine Liste aller
          derjenigen Termine aus, die zwei Samstage vor dem 22'ten
          Januar beginnen und am 16'ten Februar enden.

`t|T'
`--tomorrow' Langoption
     Liste von Daten ausgeben, die sich auf den morgigen Tag beziehen.

        * Z.B. `gcal -ct' gibt alle diejenigen Termine aus, die am
          18'ten Februar (morgen) stattfinden.

        * Z.B. `gcal -cdt' gibt alle diejenigen Termine aus, die am
          17'ten Februar (heute) und am 18'ten Februar (morgen)
          stattfinden.

`w|W[+|-]'
`--week' Langoption
`--end-of-week' Langoption
`--start-of-week' Langoption
     Liste von Daten ausgeben, die sich auf die Woche beziehen (*siehe
     `--starting-day[=ARGUMENT]': Kalender Optionen.).

        * `w' oder `--week' Langoption
          Liste von Daten vom *Starttag* der aktuellen Woche bis zum
          letzten Tag der aktuellen Woche ausgeben.

             - Z.B. `gcal -cw' gibt alle diejenigen Termine aus, die in
               der gesamten Woche, in die der 17'te Februar fällt,
               stattfinden.

        * `w+' oder `--end-of-week' Langoption
          Liste von Daten vom Tag nach dem aktuellen Tag der aktuellen
          Woche bis zum letzten Tag der aktuellen Woche ausgeben.

             - Z.B. `gcal -cw+' gibt alle diejenigen Termine aus, die am
               18'ten Februar (morgen) beginnen und am letzten Tag der
               Woche enden.

             - Z.B. `gcal -cdw+' gibt alle diejenigen Termine aus, die
               am 17'ten Februar (heute) beginnen und am letzten Tag
               der Woche enden.

        * `w-' oder `start-of-week' Langoption
          Liste von Daten vom *Starttag* der aktuellen Woche bis zum Tag
          vor dem aktuellen Tag der aktuellen Woche ausgeben.

             - Z.B. `gcal -cw-' gibt alle diejenigen Termine aus, die am
               ersten Tag der Woche beginnen und am 16'ten (gestern)
               Februar enden.

             - Z.B. `gcal -cdw-' gibt alle diejenigen Termine aus, die
               am ersten Tag der Woche beginnen und am 17'ten Februar
               (heute) enden.

`m|M[+|-]'
`--month' Langoption
`--end-of-month' Langoption
`--start-of-month' Langoption
     Liste von Daten ausgeben, die sich auf den Monat beziehen.

        * `m' oder `--month' Langoption
          Liste von Daten vom ersten Tag des aktuellen Monats bis zum
          letzten Tag des aktuellen Monats ausgeben.

             - Z.B. `gcal -cm' gibt alle diejenigen Termine aus, die im
               gesamten Monat Februar stattfinden.

        * `m+' oder `--end-of-month' Langoption
          Liste von Daten vom Tag nach dem aktuellen Tag des aktuellen
          Monats bis zum letzten Tag des aktuellen Monats ausgeben.

             - Z.B. `gcal -cm+' gibt alle diejenigen Termine aus, die am
               18'ten Februar (morgen) beginnen und am letzten Tag des
               Monats Februar enden.

             - Z.B. `gcal -cdm+' gibt alle diejenigen Termine aus, die
               am 17'ten Februar (heute) beginnen und am letzten Tag
               des Monats Februar enden.

        * `m-' oder `--start-of-month' Langoption
          Liste von Daten vom ersten Tag des aktuellen Monats bis zum
          Tag vor dem aktuellen Tag des aktuellen Monats ausgeben.

             - Z.B. `gcal -cm-' gibt alle diejenigen Termine aus, die am
               ersten Tag des Monats Februar beginnen und am 16'ten
               Februar (gestern) enden.

             - Z.B. `gcal -cdm-' gibt alle diejenigen Termine aus, die
               am ersten Tag des Monats Februar beginnen und am 17'ten
               Februar (heute) enden.

`y|Y[+|-]'
`--year' Langoption
`--end-of-year' Langoption
`--start-of-year' Langoption
     Liste von Daten ausgeben, die sich auf das Jahr beziehen.

        * `y' oder `--year' Langoption
          Liste von Daten vom ersten Tag des aktuellen Jahres bis zum
          letzten Tag des aktuellen Jahres ausgeben.

             - Z.B. `gcal -cy' gibt alle diejenigen Termine aus, die im
               gesamten Jahr stattfinden.

        * `y+' oder `--end-of-year' Langoption
          Liste von Daten vom Tag nach dem aktuellen Tag des aktuellen
          Jahres bis zum letzten Tag des aktuellen Jahres ausgeben.

             - Z.B. `gcal -cy+' gibt alle diejenigen Termine aus, die am
               18'ten Februar (morgen) beginnen und am letzten Tag des
               Jahres enden.

             - Z.B. `gcal -cdy+' gibt alle diejenigen Termine aus, die
               am 17'ten Februar (heute) beginnen und am letzten Tag
               des Jahres enden.

        * `y-' oder `--start-of-year' Langoption
          Liste von Daten vom ersten Tag des aktuellen Jahres bis zum
          Tag vor dem aktuellen Tag des aktuellen Jahres ausgeben.

             - Z.B. `gcal -cy-' gibt alle diejenigen Termine aus, die am
               ersten Tag des Jahres beginnen und am 16'ten Februar
               (gestern) enden.

             - Z.B. `gcal -cdy-' gibt alle diejenigen Termine aus, die
               am ersten Tag des Jahres beginnen und am 17'ten Februar
               (heute) enden.

Antwortdatei
------------

Wenn ein `@DATEI' Argument in der Kommandozeile vorgefunden wird, so
wird eine "Antwortdatei" DATEI benutzt, d.h. Optionen und Kommandos
werden aus dieser Datei vorgeladen.  Eine Antwortdatei `@DATEI' darf
Optionen und Kommandos enthalten, aber *keine* Verweise auf weitere
Antwortdateien.  Werden solche Verweise auf weitere Antwortdateien
vorgefunden, so werden diese ignoriert.  *Siehe
`--response-file=DATEINAME': Globale Optionen, für Hinweise wie eine
Antwortdatei automatisch erzeugt werden kann.

Das Suchschema für eine Antwortdatei ist gleich dem Suchschema für
Ressourcendateien, mit der Ausnahme, daß *keine* Standard-Antwortdatei
berücksichtigt wird.  *Siehe Datei-Suchmechanismus: Ressourcendatei,
für weitere Details.  Es dürfen mehrere Antwortdateien beim Aufruf von
Gcal angegeben werden.  Diese werden in genau der Reihenfolge
abgearbeitet, in der sie in der Kommandozeile angegeben sind, also
streng sequentiell.

Jede Option und jedes Kommando muß auf einer einzelnen Zeile angegeben
sein, d.h. durch ein echtes `\n' (Newline) Zeichen getrennt werden.
Eine Zeile der Antwortdatei, die mit einem `;' (Semikolon) Zeichen
beginnt, ist ein Kommentar und wird von Gcal vollständig ignoriert
(*siehe Zeile kommentieren::.).

Optionen müssen vor Kommandos definiert werden.  Wenn eine Antwortdatei
Kommandos enthält, so werden alle weiteren Argumente, die nach
`@DATEI' in der Kommandozeile angegeben sind, ignoriert.

Zum Beispiel:

  1. Inhalt von Antwortdatei `Datei':

          Zeile    Text
          1        -j
          2        -Cw
          EOF
          
          $ gcal -i -b 3 @Datei -s 3 1994
          
          ==> gcal -i -b 3 -j -Cw -s 3 1994

  2. Inhalt von Antwortdatei `Datei':

          Zeile    Text
          1        -j
          2        -Cw
          3        mai 1992
          EOF
          
          $ gcal -i -b 3 @Datei -s 3 1994
          
          ==> gcal -i -b 3 -j -Cw mai

  3. Inhalt von Antwortdatei `Datei':

          Zeile    Text
          1        -j
          2        -Cw
          3        mai
          4        1992
          EOF
          
          $ gcal -i -b 3 @Datei -s 3 1994
          
          ==> gcal -i -b 3 -j -Cw mai 1992

Datummodifizierer
-----------------

Es ist möglich dasjenige Datum anstelle dem aktuellen (System) Datum zu
verwenden, welches in der `%DATUM' Option definiert ist.  Das bedeutet,
daß Terminwarnungen für *jedwedes* Jahr mit demselben Warnungsniveau
wie Terminwarnungen, die sich rein auf das aktuelle Jahr beziehen,
erzeugt werden können.

Das Datum muß in einem dieser Formate angegeben werden:

   * `JJJJ[MM[TT|WWW[N]]]'

   * `JJJJ*d|wN[WWW]'

   * `JJJJ@e|DVAR[[+|-]N[WWW]]'

   * `MONATSNAME[TT]'

   * `WOCHENTAGSNAME[N]'

   * TT

Hierzu einige Beispiele:

     *Bitte beachten:*
     In den folgenden Beispielen wird angenommen, daß das heutige
     Tagesdatum Mittwoch, der 17'te Februar 1993 (19930217) ist!

Das `JJJJ[MM[TT|WWW[N]]]' Format:
        * `gcal %1994' (== JJJJ)
          Das aktuelle Datum wird auf den 17'ten Februar 1994 gesetzt
          => 19940217.

        * `gcal %1994Mär'

        * `gcal %19943'

        * `gcal %199403' (== JJJJMM)
          Das aktuelle Datum wird auf das Datum 17'ter März 1994
          gesetzt => 19940317.

        * `gcal %1994Mär3'

        * `gcal %1994033'

        * `gcal %19940303' (== JJJJMMTT)
          Das aktuelle Datum wird auf das Datum 3'ter März 1994
          gesetzt => 19940303.

        * `gcal %1994MärDon'

        * `gcal %199403do' (== JJJJMMWWW)
          Das aktuelle Datum wird auf das Datum 4'ter März 1994
          gesetzt => 19940304.

        * `gcal %1994MärMit3'

        * `gcal %199403mi3' (== JJJJMMWWWN)
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch im März
          1994 gesetzt (N == `1...5|9') => 19940316.

        * `gcal %0'

        * `gcal %00'

        * `gcal %000'

        * `gcal %0000' (== JJJJ)
          Das aktuelle Datum bleibt unverändert => 19930217.

        * `gcal %0000Mär'

        * `gcal %00003'

        * `gcal %000003' (== JJJJMM)
          Das aktuelle Datum wird auf das Datum 17'ter März 1993
          gesetzt => 19930317.

        * `gcal %0000Mär3'

        * `gcal %0000033'

        * `gcal %00000303' (== JJJJMMTT)
          Das aktuelle Datum wird auf das Datum 3'ter März 1993
          gesetzt => 19930303.

        * `gcal %0000MärDon'

        * `gcal %000003do' (== JJJJMMWWW)
          Das aktuelle Datum wird auf das Datum 4'ter März 1993
          gesetzt => 19930304.

        * `gcal %0000MärMit3'

        * `gcal %000003mi3' (== JJJJMMWWWN)
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch im März
          1993 gesetzt (N == `1...5|9') => 19930317.

Das `JJJJ*d|wN[WWW]' Format:
        * `gcal %1994*d10' (== `JJJJ*dN')
          Das aktuelle Datum wird auf das Datum des 10'ten absoluten
          Tages 1994 gesetzt (N == `1...365|366|999') => 19940110.

        * `gcal %1994*d10son' (== `JJJJ*dNWWW')
          Das aktuelle Datum wird auf das Datum des 10'ten Sonntags 1994
          gesetzt (N == `1...51|52|53|99') => 19940306.

        * `gcal %0*d10' (== `JJJJ*dN')
          Das aktuelle Datum wird auf das Datum des 10'ten absoluten
          Tages 1993 gesetzt => 19930110.

        * `gcal %0*d10son' (== `JJJJ*dNWWW')
          Das aktuelle Datum wird auf das Datum des 10'ten Sonntags 1993
          gesetzt => 19930307.

        * `gcal %1994*w10' (== `JJJJ*wN')
          Das aktuelle Datum wird auf das Datum des Montags der 10'ten
          ISO-Kalenderwoche 1994 gesetzt (N == `0|1...52|53|99')
          => 19940307.

        * `gcal %1994*w10son' (== `JJJJ*wNWWW')
          Das aktuelle Datum wird auf das Datum des Sonntags der 10'ten
          ISO-Kalenderwoche 1994 gesetzt => 19940313.

        * `gcal %0*w10' (== `JJJJ*wN')
          Das aktuelle Datum wird auf das Datum des Montags der 10'ten
          ISO-Kalenderwoche 1993 gesetzt => 19930308.

        * `gcal %0*w10son' (== `JJJJ*wNWWW')
          Das aktuelle Datum wird auf das Datum des Sonntags der 10'ten
          ISO-Kalenderwoche 1993 gesetzt => 19930314.

Das `JJJJ@e|DVAR[[+|-]N[WWW]]' Format:
        * `gcal %1994@e' (== `JJJJ@e')
          Das aktuelle Datum wird auf das Datum des Ostersonntags 1994
          gesetzt => 19940403.

        * `gcal %1994@e10'

        * `gcal %1994@e+10' (== `JJJJ@e[+]N')
          Das aktuelle Datum wird auf das Datum 10 Tage nach
          Ostersonntag 1994 gesetzt => 19940413.

        * `gcal %1994@e-10' (== `JJJJ@e-N')
          Das aktuelle Datum wird auf das Datum 10 Tage vor
          Ostersonntag 1994 gesetzt => 19940324.

        * `gcal %0@e'

        * `gcal %00@e'

        * `gcal %000@e'

        * `gcal %0000@e' (== `JJJJ@e')
          Das aktuelle Datum wird auf das Datum des Ostersonntags 1993
          gesetzt => 19930411.

        * `gcal %0@e10'

        * `gcal %0@e+10' (== `JJJJ@e[+]N')
          Das aktuelle Datum wird auf das Datum 10 Tage nach
          Ostersonntag 1993 gesetzt => 19930421.

        * `gcal %0@e-10' (== `JJJJ@e-N')
          Das aktuelle Datum wird auf das Datum 10 Tage vor
          Ostersonntag 1993 gesetzt => 19930401.

        * `gcal %1994@e3Mi'

        * `gcal %1994@e+3Mi' (== `JJJJ@e[+]NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch nach
          Ostersonntag 1994 gesetzt => 19940420.

        * `gcal %1994@e-3mi' (== `JJJJ@e-NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch vor
          Ostersonntag 1994 gesetzt => 19940316.

        * `gcal %0@e3mi'

        * `gcal %0@e+3mi' (== `JJJJ@e[+]NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch nach
          Ostersonntag 1993 gesetzt => 19930428.

        * `gcal %0@e-3mi' (== `JJJJ@e-NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch vor
          Ostersonntag 1993 gesetzt => 19930324.

        * `gcal -v a=0303 %1994@a' (== `JJJJ@DVAR')
          Das aktuelle Datum wird auf das Datum 3'ter März 1994
          gesetzt => 19940303.

        * `gcal -v a=0303 %1994@a10'

        * `gcal -v a=0303 %1994@a+10' (== `JJJJ@DVAR[+]N')
          Das aktuelle Datum wird auf das Datum 10 Tage nach dem 3'ten
          März 1994 gesetzt => 19940313.

        * `gcal -v a=0303 %1994@a-10' (== `JJJJ@DVAR-N')
          Das aktuelle Datum wird auf das Datum 10 Tage vor dem 3'ten
          März 1994 gesetzt => 19940221.

        * `gcal -v a=0303 %0@a' (== `JJJJ@DVAR')
          Das aktuelle Datum wird auf das Datum 3'ter März 1993
          gesetzt => 19930303.

        * `gcal -v a=0303 %0@a10'

        * `gcal -v a=0303 %0@a+10' (== `JJJJ@DVAR[+]N')
          Das aktuelle Datum wird auf das Datum 10 Tage nach dem 3'ten
          März 1993 gesetzt => 19930313.

        * `gcal -v a=0303 %0@a-10' (== `JJJJ@DVAR-N')
          Das aktuelle Datum wird auf das Datum 10 Tage vor dem 3'ten
          März 1993 gesetzt => 19930221.

        * `gcal -v a=0303 %1994@a3mi'

        * `gcal -v a=0303 %1994@a+3mi' (== `JJJJ@DVAR[+]NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch nach dem
          3'ten März 1994 gesetzt => 19940323.

        * `gcal -v a=0303 %1994@a-3mi' (== `JJJJ@DVAR-NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch vor dem
          3'ten März 1994 gesetzt => 19940216.

        * `gcal -v a=0303 %0@a3mi'

        * `gcal -v a=0303 %0@a+3mi' (== `JJJJ@DVAR[+]NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch nach dem
          3'ten März 1993 gesetzt => 19930324.

        * `gcal -v a=0303 %0@a-3mi' (== `JJJJ@DVAR-NWWW')
          Das aktuelle Datum wird auf das Datum 3'ter Mittwoch vor dem
          3'ten März 1993 gesetzt => 19930210.

Das `MONATSNAME[TT]' Format:
        * `gcal %April' (== MONATSNAME)
          Das aktuelle Datum wird auf das Datum 17'ter April 1993
          gesetzt => 19930417.

        * `gcal %april3'

        * `gcal %april03' (== MONATSNAME TT)
          Das aktuelle Datum wird auf das Datum 3'ter April 1993
          gesetzt => 19930403.

Das `WOCHENTAGSNAME[N]' Format:
        * `gcal %Freitag' (== WOCHENTAGSNAME)
          Das aktuelle Datum wird auf das Datum des Freitags der
          laufenden Woche im Februar 1993 gesetzt => 19930219.

        * `gcal %Freitag2'

        * `gcal %Freitag02' (== WOCHENTAGSNAME N)
          Das aktuelle Datum wird auf das Datum 2'ter Freitag im
          Februar 1993 gesetzt (N == `1...5|9') => 19930212.

Das TT Format:
        * `gcal %3'

        * `gcal %03' (== TT)
          Das aktuelle Datum wird auf das Datum 3'ter Februar 1993
          gesetzt => 19930203.

Kommandos
---------

Die Kommandos steuern die Zeiträume, die von Gcal berücksichtigt
werden.  Kommandos können in vier Hauptklassen eingeteilt werden,
nämlich "einzelne" Kommandos, spezielle "3-Monatsmodus" Kommandos,
"Listen" von Kommandos und "Bereiche" von Kommandos.  Einzelne und
spezielle 3-Monatsmodus Kommandos erzeugen nur *ein* Kalenderblatt,
Listen oder Bereiche von Kommandos erzeugen *mehr als ein*
Kalenderblatt je Programmlauf.  Wenn eine Liste von Kommandos gegeben
ist, so arbeitet Gcal jedes einzelne Kommando dieser Liste sequentiell
ab, eins nach dem anderen.  Ein Bereich von Kommandos wird von Gcal
zuerst in einzelne Kommandos expandiert, sodann arbeitet Gcal jedes
einzelne Kommando, welches nach der internen Expansion erzeugt wurde,
sequentiell ab.

Um die verwendete Notation im nachstehenden Text zu verstehen,
bezeichnet MM entweder eine Zahl, einen Monatsnamen oder eines der
speziellen 3-Monatsmodus Kommandos `.', `..', `.+' und `.-'.  Es
können weder Listen noch Bereiche von Monaten oder Jahren erzeugt
werden falls ein spezielles 3-Monatsmodus Kommando angegeben wurde.

Der Bereich von MM ist gültig von 1 bis 12 oder gültig von Januar bis
Dezember (beide Notationen dürfen gemischt verwendet werden).
Monatsnamen dürfen bis auf ihre ersten drei Zeichen abgekürzt werden.
JJJJ ist eine Zahl.  Der Bereich von JJJJ ist gültig von 1 bis 9999.
Ein Bereich (MM-MM JJJJ+JJJJ ...) besteht aus genau zwei Elementen.
Eine Liste (MM,...,MM JJJJ;...;JJJJ ...) muß mindestens zwei Elemente
enthalten, und darf unbegrenzt viele Elemente enthalten.

Hier ist eine Aufstellung aller benutzten Bereichs-, Listen- und
sonstigen Kommandotrennzeichen:

       1. Das `-' Zeichen ist das *Bereich von Monaten* Trennzeichen.

       2. Das `,' Zeichen ist das *Liste von Monaten* Trennzeichen.

       3. Das `+' Zeichen ist das *Bereich von Jahren* Trennzeichen.

       4. Das `;' Zeichen ist das *Liste von Jahren* Trennzeichen.

       5. Das `/' Zeichen ist das *Monat des Jahres* Trennzeichen.

       6. Das `:' Zeichen ist das *Fiskaljahr* Trennzeichen.

Einfache Kommandos
..................

`KEINES'
     Aktueller Monat des aktuellen Jahres, wird weiterhin als
     "Einzelmonatsmodus" bezeichnet.

`MONATSNAME'
     Angegebener Monat des aktuellen Jahres, z.B.:

          gcal mai
          gcal OKTOBER
          gcal ja

`JJJJ'
     Angegebenes Jahr, wird weiterhin als "Einzeljahresmodus"
     bezeichnet, z.B.:

          gcal 1992

     Aber es gibt eine Ausnahme von dieser generellen Regel.  Wenn die
     angegebene Jahreszahl kleiner oder gleich zwölf ist, so nimmt
     Gcal an, daß ein angegebener Monat des aktuellen Jahres
     gewünscht ist.  Wenn ein angegebenes Jahr kleiner oder gleich
     zwölf gewünscht wird, so sollte Gcal entweder so

          gcal 1:6

     oder so

          gcal 6+6

     aufgerufen werden, um beispielsweise das Jahr sechs nach Christus
     zu erhalten.

`MM JJJJ'
`MM/JJJJ'
     Angegebener Monat eines angegebenen Jahres, z.B.:

          gcal 9 1992
          gcal 9/1992
          gcal Nov 1777
          gcal Nov/1777

`:'
     Einzelnes Fiskaljahr (abweichendes Wirtschaftsjahr), beginnend im
     *aktuellen Monat* des *aktuellen Jahres* und endend im Monat
     *aktueller Monat*-1 des *aktuellen Jahres*+1, wird weiterhin als
     "implizites Fiskaljahr" bezeichnet, z.B.:

          gcal :

`MM:'
     Einzelnes Fiskaljahr, beginnend im Monat MM des *aktuellen Jahres*
     und endend im Monat MM-1 des *aktuellen Jahres*+1, wird weiterhin
     als "explizites Fiskaljahr" bezeichnet, z.B.:

          gcal 6:
          gcal feb:
          gcal NOVEMBER:

`:JJJJ'
     Einzelnes Fiskaljahr, beginnend im aktuellen Monat des Jahres JJJJ
     und endend im Monat *aktueller Monat*-1 des Jahres JJJJ+1, wird
     weiterhin auch als "explizites Fiskaljahr" bezeichnet, z.B.:

          gcal :1999

`MM:JJJJ'
     Einzelnes Fiskaljahr, beginnend im Monat MM des Jahres JJJJ und
     endend im Monat MM-1 des Jahres JJJJ+1, wird weiterhin auch als
     "explizites Fiskaljahr" bezeichnet, z.B.:

          gcal 7:1999
          gcal okt:1992
          gcal Februar:1777

3-Monatsmodus Kommandos
.......................

`.'
     Vorheriger, aktueller und nächster Monat des laufenden Jahres,
     z.B.:

          gcal .

`. JJJJ'
     Vorheriger, aktueller und nächster Monat des angegebenen Jahres,
     z.B.:

          gcal . 1992

`..'
     Aktuelles Quartal des laufenden Jahres, z.B.:

          gcal ..

`.. JJJJ'
     Aktuelles Quartal des angegebenen Jahres, z.B.:

          gcal .. 1992

`.+'
     Aktueller und die beiden nächsten Monate des laufenden Jahres,
     z.B.:

          gcal .+

`.+ JJJJ'
     Aktueller und die beiden nächsten Monate des angegebenen Jahres,
     z.B.:

          gcal .+ 1992

`.-'
     Aktueller und die beiden vorhergehenden Monate des laufenden
     Jahres, z.B.:

          gcal .-

`.- JJJJ'
     Aktueller und die beiden vorhergehenden Monate des angegebenen
     Jahres, z.B.:

          gcal .- 1992

Listen von Kommandos
....................

`MM,...,MM'
     Liste von angegebenen Monaten des aktuellen Jahres, z.B.:

          gcal 1,5,12
          gcal 3,1,5,3
          gcal juni,9,jan

`MM/JJJJ,...,MM/JJJJ'
     Liste von angegebenen Monaten in angegebenen Jahren, z.B.:

          gcal 1/1992,5,12/2001
          gcal juni/1991,9/1801,jan

`MM,...,MM JJJJ'
     Liste von angegebenen Monaten eines angegebenen Jahres, z.B.:

          gcal 3,7 1999
          gcal 1,dez,juli 1777

`JJJJ;...;JJJJ'
     Liste von angegebenen Jahren, z.B.:

          gcal 1992;1777;1899

`MM:JJJJ;...;MM:JJJJ'
     Liste von angegebenen Fiskaljahren, z.B.:

          gcal 7:1999;8:1992;April:3

*Andere gültige Listen:*

`MM,MM/JJJJ,...'
     Gemischte Monatsliste bestehend aus: `MM MM/JJJJ'

          gcal 6,8,3/1999,feb/3,januar

`MM:;MM:JJJJ,...'
     Gemischte Liste von Fiskaljahren von aktuellen/angegebenen Jahren
     bestehend aus: `MM: :JJJJ MM:JJJJ JJJJ'

          gcal 3:;1994;februar:1999;:1777;JAN:

`MM:;MM:;...'
     Liste von Fiskaljahren des aktuellen Jahres bestehend aus: `MM:'

          gcal 3:;august:;DEZ:

Bereiche von Kommandos
......................

`MM-MM'
     Bereich von angegebenen Monaten des aktuellen Jahres, z.B.:

          gcal 3-7
          gcal 11-8
          gcal MAI-dez
          gcal 12-aug

`MM/JJJJ-MM/JJJJ'
     Bereich von angegebenen Monaten von angegebenen Jahren, z.B.:

          gcal 3/1991-juli/1992
          gcal dez/1994-3
          gcal sep-dez/2000

`MM-MM JJJJ'
     Bereich von angegebenen Monaten eines angegebenen Jahres, z.B.:

          gcal 3-7 1999
          gcal nov-3 1777
          gcal aug-dez 1992

`MM JJJJ-JJJJ'
`MM/JJJJ-JJJJ'
     Bereich eines angegebenen Monats von angegebenen Jahren, z.B.:

          gcal AUGUST 1494-1497
          gcal 3/1993-1999
          gcal nov/3-1777

`JJJJ+JJJJ'
     Bereich von angegebenen Jahren, z.B.:

          gcal 1992+1994

`MM:JJJJ+MM:JJJJ'
     Bereich von angegebenen Fiskaljahren, z.B.:

          gcal 7:1999+8:1992
          gcal aug:1992+juli:1999

Die `GCAL' Umgebungsvariable
============================

In der Umgebungsvariable `GCAL' können Grundeinstellungen zu Optionen
für Gcal gespeichert werden (*siehe GCAL: Umgebungsvariablen.).  Diese
Optionen werden bei Programmstart zuerst interpretiert und einige von
ihnen können durch explizit gegebene Kommandozeilenargumente oder
Werte, die in der Antwortdatei `@DATEI' vorhanden sind, überschrieben
werden.  *Siehe Kommandozeilenargumente::, und *Siehe Antwortdatei::.

Zum Beispiel

   * für *sh*:

          GCAL="-i @farbe -b 3"; export GCAL

   * für *csh*:

          setenv GCAL "-i @farbe -b 3"

   * für *MS-DOS*:

          set GCAL=-i @farbe -b 3

Unter Vax/VMS lautet der Name der Umgebungsvariable `GCAL_OPT', um
einen Konflikt mit dem gesetzten Symbol `GCAL', welches zum Aufruf des
Programms dient, zu vermeiden.

Zum Beispiel

   * für *VMS*:

          define GCAL_OPT "-i @farbe -b 3"

Ewige Feiertage
***************

Die *ewige Feiertagsliste* wird nur für Jahre nach A.D.463 erzeugt.
Sie kann auf mehrere Arten und Weisen ausgegeben werden:

Wenn Gcal ohne explizites (Fiskal) Datum mit dem *ewige Feiertagsliste*
Argument gestartet wird (*siehe `--holiday-list[=long|short]': Kalender
Optionen.), z.B.:

     gcal --holiday-list
     gcal -n
     gcal -n :

so gibt Gcal ohne einen vorangehenden Kalender alle diejenigen
Feiertage aus der ewigen Feiertagsliste aus, die sich auf das aktuelle
Jahr bzw. Fiskaljahr beziehen.

Wenn Gcal mit dem *ewige Feiertagsliste* Argument und einem Monat (plus
eines Jahres) gestartet wird, z.B.:

     gcal --holiday-list juli
     gcal -n juli
     gcal -n 7 1993
     gcal -n 7/1993

so gibt Gcal einen Monatskalender des angegebenen Monats (des Jahres)
und nachfolgend alle diejenigen Feiertage aus der ewigen Feiertagsliste
aus, die sich auf den angegebenen Monat (des angegebenen Jahres)
beziehen.

Wenn Gcal mit dem *ewige Feiertagsliste* Argument und einem einfachen
Jahr oder einem Fiskaljahr (abweichendes Wirtschaftsjahr) gestartet
wird, z.B.:

     gcal --holiday-list 1993
     gcal -n 1993
     gcal -n juli:
     gcal -n :1993
     gcal -n 7:1993

so gibt Gcal einen Jahreskalender des angegebenen Jahres und nachfolgend
alle diejenigen Feiertage aus der ewigen Feiertagsliste aus, die sich
auf das angegebene Jahr bzw. Fiskaljahr beziehen.

Wenn Gcal mit dem *ewige Feiertagsliste* Argument und einem der
speziellen 3-Monatsmodus Kommandos gestartet wird (*siehe `. JJJJ':
3-Monatsmodus Kommandos.), z.B.:

     gcal --holiday-list .
     gcal -n .
     gcal -n ..
     gcal -n .+
     gcal -n .-

so gibt Gcal die bezogenen 3 Monate im festen Layout/Stil eines
Jahreskalenders aus sowie nachfolgend alle diejenigen Feiertage aus der
ewigen Feiertagsliste aus, die sich auf diese Monate beziehen.

Wenn Gcal mit dem *ewige Feiertagsliste* Argument und einer *Liste*
oder einem *Bereich* von Kommandos gestartet wird, so werden
entsprechende Folgen von ewigen Feiertagslisten produziert.  *Siehe
`MM,...,MM': Listen von Kommandos, und *Siehe `MM-MM': Bereiche von
Kommandos, für weitere Details.

Terminwarnungen
***************

Dieses Kapitel beschreibt wie Gcal für *Terminwarnungszwecke* benutzt
werden kann.  Dazu darf eine Gcal spezifische Ressourcendatei erzeugt
werden, welche Einträge zur Terminwarnung enthält (*siehe
Ressourcendatei::.).

Jedesmal wenn Gcal im einfachen Einzelmonatsmodus ausgeführt wird,
d.h. beim Aufruf von Gcal wurde in der Kommandozeile weder ein
expliziter Monat noch ein explizites Jahr bzw. Fiskaljahr angegeben,
aber das *Terminwarnung* Argument vorgefunden wird, z.B.:

     gcal --list-of-fixed-dates
     gcal -c

so durchsucht Gcal die Ressourcendatei nach Daten und verarbeitet genau
solche, die sich auf das aktuelle (==heutige) Datum beziehen.  Sodann
gibt Gcal ohne einen vorangehenden Kalender alle diejenigen
Terminwarnungen aus der Ressourcendatei aus, die sich auf den aktuellen
Tag (Woche/Monat/Jahr) des aktuellen Jahres beziehen.

Einige weitere Beispiele hierzu:

     gcal -ce
     gcal -cw-
     gcal -c-m
     gcal -c-y-
     gcal -jcb -c-et
     gcal -cey-
     gcal -jc -cey

Die Liste der Terminwarnungen kann auf mehrere Arten und Weisen
ausgegeben werden:

Wenn Gcal mit dem *Terminwarnung* Argument und/oder einem Monat und/oder
einem expliziten Jahr bzw. Fiskaljahr gestartet wird; bzw. mit einem der
speziellen 3-Monatsmodus Kommandos, z.B.:

     gcal -c juli
     gcal -ce 7 1994
     gcal -c-y 7/1994
     gcal -c 7:1993
     gcal -c 1993
     gcal -c .
     gcal -c .+

so gibt Gcal einen (drei) Monats-/ Jahreskalender des angegebenen bzw.
aktuellen Monats-/ Jahres aus und nachfolgend alle diejenigen
Terminwarnungen aus der Ressourcendatei, die sich auf den angegebenen
Zeitraum beziehen; das Warnungsniveau ist wie bei der `-cy' Option,
wenn sich der Warnungszeitraum auf ein Jahr bzw. Fiskaljahr bezieht
oder auf eine 3-Monatsperiode, bzw.  wie bei der `-cm' Option, wenn
sich der Warnungszeitraum auf einen Monat bezieht.

Wenn Gcal ohne explizites Datum mit dem *Terminwarnung* Argument *in
Verbindung mit* dem *ewige Feiertagsliste* Argument gestartet wird,
z.B.:

     gcal -c -n
     gcal -Cm -n
     gcal -Cl1224 -n
     gcal -cl3+ -n

so gibt Gcal ohne einen vorangehenden Kalender alle diejenigen
Terminwarnungen aus der Ressourcendatei aus, die sich auf den
angegebenen Warnungszeitraum im aktuellen Jahr beziehen, und
nachfolgend alle diejenigen Feiertage aus der ewigen Feiertagsliste
aus, die sich auf das gesamte aktuelle Jahr beziehen.  Für weitere
Details zur *ewigen Feiertagsliste*, siehe *Siehe Ewige Feiertage::.

*Anmerkung zu vorhergehenden Beispielen:*

Falls das *Standard/Spezielle Kalenderformat* Argument oder das
*Starttag der Woche* Argument (ausgenommen der `--starting-day=today'
bzw. `--starting-day=0' Option) zudem mit vorgefunden wird, z.B.:

     gcal -c -n -i
     gcal -c -i-
     gcal -n -i- :
     gcal -n -s Sonntag

so gibt Gcal einen Monats-/ Jahreskalender vor jeder anderen
angeforderten Liste aus!  *Siehe `--type=special|standard': Kalender
Optionen, und *Siehe `--starting-day[=ARGUMENT]': Kalender Optionen,
für mehr Informationen.

Jedesmal wenn Gcal im einfachen Einzeljahresmodus ausgeführt wird,
d.h. beim Aufruf von Gcal wurde in der Kommandozeile weder ein
expliziter Monat noch ein explizites Jahr bzw. Fiskaljahr angegeben,
aber das *Terminwarnung* Argument (evtl. mit Modifizierern) und das
*Anzahl der Monatsblöcke* Argument vorgefunden wird (*siehe
`--blocks=ANZAHL': Kalender Optionen.), z.B.:

     gcal -c --blocks=3
     gcal -C-em -b 3
     gcal -c-t -b 6 -jc

so durchsucht Gcal die Ressourcendatei nach Daten und verarbeitet genau
jene, die sich auf das aktuelle (==heutige) Datum beziehen.  Sodann
gibt Gcal einen vorangehenden Jahreskalender und alle diejenigen
Terminwarnungen aus der Ressourcendatei aus, die sich auf den aktuellen
Tag (Woche/Monat/Jahr) des aktuellen Jahres beziehen.

Es können aber auch Daten von vergangenen, aktuellen oder zukünftigen
Monaten/Jahren verarbeitet werden.  Das geht einerseits, indem die
`%DATUM' Option entsprechend verwendet wird (*siehe
Datummodifizierer::.), oder andererseits, indem ein Kommando bzw.  eine
*Liste* oder ein *Bereich* von Kommandos verwendet wird.

Zum Beispiel:

`gcal -c -n- 1993'
     Ausgabe aller Termine in aufsteigender Reihenfolge, welche sich
     auf das gesamte Jahr 1993 beziehen, sowie der ewigen
     Feiertagsliste in absteigender Reihenfolge, welche sich auch auf
     das gesamte Jahr 1993 bezieht; das Warnungsniveau ist wie bei der
     `-cy' Option.

`gcal -c- juli:1993'
     Ausgabe aller Termine in absteigender Reihenfolge, welche sich auf
     das Fiskaljahr - beginnend im Monat Juli 1993 und endend im Monat
     Juni 1994 - beziehen; das Warnungsniveau ist wie bei der `-cy'
     Option.

`gcal -ce juli 1993'
     Ausgabe aller Termine in aufsteigender Reihenfolge, welche sich
     auf den Monat Juli 1993 beziehen, einschließlich aller ewigen
     Feiertage dieses Zeitraums, welche in diese Liste eingefügt
     werden; das Warnungsniveau ist wie bei der `-cm' Option.

`gcal -c-e -n 1993+1996'
     Ausgabe aller Termine in absteigender Reihenfolge, welche sich auf
     die gesamten Jahre 1993, 1994, 1995 und 1996 beziehen (Jahr für
     Jahr in Folge), einschließlich aller ewigen Feiertage dieses
     Zeitraums, welche in diese Liste eingefügt werden, sowie der
     ewigen Feiertagsliste in aufsteigender Reihenfolge, welche sich
     ebenfalls auf diese Jahre bezieht; das Warnungsniveau ist wie bei
     der `-cy' Option.

Ressourcendatei
===============

Dieser Textteil beschreibt wie eine "Ressourcendatei", welche Einträge
zur Terminwarnung enthält, benutzt wird.  Der Name der
Standard-Ressourcendatei ist `~/.gcalrc' (1).

Gcal benutzt einen speziellen Datei-Suchmechanismus:

  1. Das Gcal Programm erwartet die Standard-Ressourcendatei im
     Dateiverzeichnis, welches in der Umgebungsvariable `HOME'
     angegeben ist.  Falls die Umgebungsvariable `HOME' weder definiert
     noch gesetzt ist, so übergeht Gcal diesen Schritt.  *Siehe HOME:
     Umgebungsvariablen.

  2. Sollte vorherige Aktion versagt haben, so durchsucht Gcal
     diejenigen Dateiverzeichnisse nach der Standard-Ressourcendatei,
     welche in der Umgebungsvariable `GCALPATH' (*siehe GCALPATH:
     Umgebungsvariablen.) angegeben sind.  Die Umgebungsvariable
     `GCALPATH' enthält eine durch `:' (2) Doppelpunkt getrennte Liste
     von Dateiverzeichnissen.  Falls eine solche Umgebungsvariable
     weder definiert noch gesetzt ist, so übergeht Gcal diesen Schritt.

  3. Sollte vorherige Aktion versagt haben, so inspiziert Gcal das
     *Benutzer-Datenverzeichnis* (normalerweise `$HOME/share/gcal')
     nach der Standard-Ressourcendatei.  Dieses Verzeichnis ist ein
     Dateiverzeichnis relativ zum `HOME' Dateiverzeichnis.  Falls eine
     `GCAL_USR_DATADIR' Umgebungsvariable gesetzt ist, so wird Gcal den
     Inhalt dieser Umgebungsvariable an den Inhalt der `HOME'
     Umgebungsvariable anfügen, und zuerst diesen
     Dateiverzeichnisnamen anstelle des beim Kompilationsvorgangs
     eingebrannten Dateiverzeichnisnamens benutzen (*siehe
     GCAL_USR_DATADIR: Umgebungsvariablen.).  Falls die
     Umgebungsvariable `HOME' weder definiert noch gesetzt ist, so
     übergeht Gcal diesen Schritt.

  4. Sollten alle bisherigen Aktionen versagt haben, so inspiziert Gcal
     das *System-Datenverzeichnis* (normalerweise
     `/usr/local/share/gcal' oder `$(prefix)/share/gcal') nach der
     Standard-Ressourcendatei.  Dieses Verzeichnis ist ein
     Dateiverzeichnis absolut zum *Wurzel*/*$(prefix)*
     Dateiverzeichnis.  Falls eine `GCAL_SYS_DATADIR' Umgebungsvariable
     gesetzt ist, so wird Gcal zuerst diesen Dateiverzeichnisnamen
     anstelle des beim Kompilationsvorgang eingebrannten
     Dateiverzeichnisnamens benutzen (*siehe GCAL_SYS_DATADIR:
     Umgebungsvariablen.).

Falls die Standard-Ressourcendatei nicht während der Schritte 1...4 des
Datei-Suchmechanismus' aufgefunden wurde, so werden keinerlei
Terminwarnungen erzeugt!

Wenn ein `-f|F DATEINAME[+...]' bzw.  `--resource-file=DATEINAME'
Kommandozeilenargument vorgefunden wird, so wird eine Datei DATEINAME
anstelle der Standard-Ressourcendatei als Ressourcendatei benutzt.
*Siehe `--resource-file=DATEINAME': Terminwarnung Optionen.

Ein "erweiterter Dateiname" enthält ein oder mehrere `/' (3) Zeichen
und bezeichnet eine Datei, deren Zugriffspfad entweder vom
Wurzeldateiverzeichnis (root-directory) aus fest vorgegeben ist, wie
z.B.  `/foo/bar/file', oder vom aktuellen Dateiverzeichnis aus fest
vorgegeben ist, wie z.B. `./bar/file' oder `../bar/file'.  Falls
DATEINAME ein erweiterter Dateiname ist:

     Wenn DATEINAME vorgefunden wird, so wird Gcal diese Datei
     auswerten.
     Wenn DATEINAME nicht vorgefunden wird, so wird Gcal diese Datei
     nicht auswerten.

Ein "einfacher Dateiname" enthält keinen Verweis auf einen
Zugriffspfad, der entweder vom Wurzeldateiverzeichnis oder vom
aktuellen Dateiverzeichnis aus fest vorgegeben ist, wie z.B. `file'
oder `bar/file'.  Falls DATEINAME ein einfacher Dateiname ist:

     Gcal wird versuchen, die Datei DATEINAME unter Zuhilfenahme des
     zuvor erklärten Datei-Suchmechanismus' aufzufinden.

  ---------- Fussnoten ----------

  (1)  Unter MS-DOS, OS/2 und einigen anderen Betriebssystemen ist der
Name der Standard-Ressourcendatei `~/gcalrc'.

  (2)  Unter MS-DOS, OS/2 und einigen anderen Betriebssystemen wird ein
anderes Zeichen verwendet, z.B. `;' unter MS-DOS und OS/2.

  (3)  Betriebssysteme wie z.B. MS-DOS oder OS/2 verwenden das `\'
Zeichen, mit dem ein Dateiverzeichnis von einem Dateinamen separiert
wird.

Struktur einer Ressourcendatei
------------------------------

Eine Gcal Ressourcendatei ist zunächst einmal eine reine ASCII
Textdatei, die mit einem beliebigen Texteditor oder durch Umlenkung des
*Standardausgabe-Gerätekanals* in eine Datei erzeugt werden kann, z.B.:

     $ echo '19930217 Text'>> Ressourcendatei RET

Jede Ressourcendatei muß eine besondere, aber einfache Zeilenstruktur
aufweisen, so daß Gcal auch in der Lage ist, deren Inhalt zu
interpretieren.  Jeder Termineintrag, welcher in einer Zeile einer
Ressourcendatei vorgenommen wurde, muß in zwei Teile aufgespalten
werden, nämlich einerseits in einen *Datumteil* und andererseits in
einen optionalen *Textteil*, welche durch mindestens *ein* "whitespace"
Trennzeichen (Tab, Space, Form-Feed ...) voneinander abgetrennt werden
müssen.  Wird kein *Textteil* angegeben, so entfällt natürlich auch
die Angabe des zur Trennung dieser beiden Teile notwendigen
*whitespace* Zeichens.

Eine Zeile muß stets mit einem `\n' (Newline) Zeichen enden,
ausgenommen es ist die letzte Zeile in einer Ressourcendatei.  Die
maximale Länge einer Zeile ist allerdings begrenzt auf INT_MAX (1)
Zeichen.  Bei Umlenkung des *Standardausgabe-Gerätekanals* in eine
Datei wird der Zeile automatisch ein Newline Zeichen angefügt, bei
Benutzung von einem Texteditor normalerweise dann, wenn die
geschriebene Zeile mittels der RET Taste abgeschlossen wird.  Sollte
der verwendete Texteditor hinsichtlich der Wirkungsweise der RET Taste
und der Generierung des damit verbundenen Newline Zeichens nicht wie
angegeben arbeiten, so sollte der Texteditor in diese Betriebsart
versetzt werden.  Sollte das nicht möglich sein, so ist der verwendete
Texteditor für die Erzeugung von Gcal Ressourcendateien unbrauchbar!

Die Zeilenstruktur eines Termineintrags ist:

     DATUMTEIL [ *whitespace* TEXTTEIL ] *newline*

oder konkreter, z.B.:

     JJJJ[MM[TT|WWW[N]]] [ *whitespace* TEXT ] *newline*

oder noch konkreter, z.B.:

     19940217 Hallo, ich bin der Text!

Neben Einträgen zur Terminwarnung können noch weitere Einträge in
einer Ressourcendatei vorgenommen werden, wie:

Include Anweisungen...

     #include <DATEINAME>
     #include "DATEINAME"

Datumvariablenzuweisungen-/ operationen...

     DVAR=NICHTS
     DVAR=MMTT
     DVAR=MMWWWN
     DVAR=*dN[WWW]
     DVAR=*wN[WWW]
     DVAR=DVAR[[+|-]N[WWW]]
     DVAR++
     DVAR--
     DVAR+=N[WWW]
     DVAR-=N[WWW]

Textvariablenzuweisungen...

     TVAR=[TEXT]

Textvariablenreferenzen...

     TVAR

Textvariablenreferenzen zu Anfang einer Zeile der Gcal Ressourcendatei
dürfen allerdings nur dann verwendet werden, falls sichergestellt ist,
daß sich nach deren vollständiger Expansion eine gültige Zeile der
Gcal Ressourcendatei ergibt.

  ---------- Fussnoten ----------

  (1)  Normalerweise entspricht das zum Beispiel auf einer 16-Bit
Maschinenarchitektur dem Wert 32.767 == (2^15)-1; auf einer 32-Bit
Maschinenarchitektur dem Wert 2.147.483.647 == (2^31)-1 usw.

Datumteil einer Zeile
---------------------

Die Struktur von einem "Datumteil" - welcher Gcal die Information gibt
wann ein Termin stattfindet - einer Zeile der Gcal Ressourcendatei ist

*Entweder*: `JJJJ[MM[TT|WWW[N]]]'

    `JJJJ'
          (4 Ziffern), ist das Jahr einschließlich des Jahrhunderts
          (Bereich 0000...9999).  Es sind führende Nullen anzugeben
          falls das Jahr kleiner 1000 ist und weitere Komponenten des
          Datumteils dem Jahr folgen.

    `MM'
          (2 Ziffern oder 3 Zeichen), ist der Monat (Bereich 00...12
          oder 99, bzw.  Jan, Feb...).  99 kodiert stets den letzten
          Monat eines Jahres (== Dezember). Es sind führende Nullen
          anzugeben falls der Monat kleiner 10 ist und weitere
          Komponenten des Datumteils dem Monat folgen.

    `TT'
          (2 Ziffern), ist der Tag (Bereich 00...31 oder 99).  99
          kodiert stets den letzten Tag eines Monats.  Es sind
          führende Nullen anzugeben falls der Tag kleiner 10 ist und
          weitere Komponenten des Datumteils dem Tag folgen.

    `WWW'
          (2...3 Zeichen), ist ein Wochentagsname im Kurzformat (Bereich
          Mon...Son).

    `N'
          (1 Ziffer), ist der N'te Wochentag WWW im Monat (Bereich
          1...5 oder 9).

             * N == 1...5
               N'ter WWW Wochentag im Monat.

             * N == 9
               Letzter WWW Wochentag im Monat.

*Oder*: `JJJJ*d|wN[WWW]'

    `JJJJ'
          (4 Ziffern), ist das Jahr einschließlich des Jahrhunderts
          (Bereich 0000...9999).  Es sind führende Nullen anzugeben
          falls das Jahr kleiner 1000 ist und weitere Komponenten des
          Datumteils dem Jahr folgen.

    `*d'
          (2 Zeichen), ist ein Bezug auf ein gewöhnliches Tagesdatum.

    `*w'
          (2 Zeichen), ist ein Bezug auf ein ISO-8601:1988 Wochendatum.

    `N'
          (1...3 Ziffern), ist der Wert in Tagen oder Wochen, an
          welchem der Termin auftritt.  99 in Verbindung mit einem
          Wochentagsnamen im Kurzformat kodiert stets den letzten
          Wochentag WWW eines Jahres.  999 in Verbindung mit `*d'
          kodiert stets den letzten Tag eines Jahres, also den 31'ten
          Dezember.  Falls das berechnete Datum nicht im Jahr auftritt,
          also außerhalb der Jahresgrenzen liegt, so wird die
          Terminwarnung unterdrückt.

    `WWW'
          (2...3 Zeichen), ist ein Wochentagsname im Kurzformat (Bereich
          Mon...Son).

*Oder*: `JJJJ@e|DVAR[[+|-]N]'

    `JJJJ'
          (4 Ziffern), ist das Jahr einschließlich des Jahrhunderts
          (Bereich 0000...9999).  Es sind führende Nullen anzugeben
          falls das Jahr kleiner 1000 ist und weitere Komponenten des
          Datumteils dem Jahr folgen.

    `@e'
          (2 Zeichen), ist ein Bezug auf das Datum des Ostersonntags.

    `@DVAR'
          (2 Zeichen), ist ein Bezug auf ein Datumvariable.

    `[+|-]N'
          (1...4 alphanumerische Zeichen), ist der optionale Versatz in
          Tagen, an welchem der Termin relativ zum Datum des
          Ostersonntags oder zum Datum der Datumvariablen auftritt.
          -999 kodiert stets den ersten Tag eines Jahres, also den
          1'ten Januar.  +999 oder 999 kodiert stets den letzten Tag
          eines Jahres, also den 31'ten Dezember.  Falls das berechnete
          Datum nicht im Jahr auftritt, also außerhalb der
          Jahresgrenzen liegt, so wird die Terminwarnung unterdrückt.

*Oder*: `JJJJ@e|DVAR[+|-]NWWW'

    `JJJJ'
          (4 Ziffern), ist das Jahr einschließlich des Jahrhunderts
          (Bereich 0000...9999).  Es sind führende Nullen anzugeben
          falls das Jahr kleiner 1000 ist und weitere Komponenten des
          Datumteils dem Jahr folgen.

    `@e'
          (2 Zeichen), ist ein Bezug auf das Datum des Ostersonntags.

    `@DVAR'
          (2 Zeichen), ist ein Bezug auf ein Datumvariable.

    `[+|-]NWWW'
          (3...7 alphanumerische Zeichen), ist der optionale Versatz in
          Wochentagen, an welchem der Termin relativ zum Datum des
          Ostersonntags oder zum Datum der Datumvariablen auftritt.
          -99 kodiert stets den ersten Wochentag WWW eines Jahres.  +99
          oder 99 kodiert stets den letzten Wochentag WWW eines Jahres.
          Falls das berechnete Datum nicht im Jahr auftritt, also
          außerhalb der Jahresgrenzen liegt, so wird die Terminwarnung
          unterdrückt.

*Bitte beachten:*

   * Falls JJJJ nicht als festes Jahr, sondern als 0000 angegeben ist:
     Es wird angenommen, daß der Monat und Tag jährliche Ereignisse
     sind, und der *Textteil* wird für jedes Jahr ausgegeben.

   * Falls MM nicht als fester Monat, sondern als 00 oder gar nicht
     angegeben ist:
     Es wird angenommen, daß der Tag ein monatliches Ereignis im
     angegebenen Jahr ist, und der *Textteil* wird für jeden Monat
     ausgegeben.

   * Falls TT nicht als fester Tag, sondern als 00 oder gar nicht
     angegeben ist:
     Es wird angenommen, daß der Tag ein tägliches Ereignis im
     angegebenen Monat und Jahr ist, und der *Textteil* wird für jeden
     Tag ausgegeben.

   * Falls ein Wochentagsname WWW im 2...3-stelligen Kurzformat
     angegeben ist, z.B.: `Mon, Die...'
     Es wird angenommen, daß der gegebene Wochentagsname ein
     wöchentliches Ereignis im angegebenen Monat und Jahr ist, und der
     *Textteil* wird für jede Woche ausgegeben.

Weitere Datumteil-Attribute
---------------------------

Der Datumteil einer Gcal Ressourcendatei darf mit weiteren Attributen
ausgestattet werden.  Weitere Attribute sind entweder die Angabe einer
Liste von Tagen oder eines Bereichs von Tagen, in welchem der Termin
stattfinden soll.  Weitere Attribute sind auch Faktoren, welche eine
Wiederholungsdauer oder einen Auftretenszeitpunkt eines Termins
bestimmen.

Grundsätzlich dürfen alle folgendermaßen strukturierten Datumteile
einer Gcal Ressourcendatei mit weiteren Attributen versehen werden:

   * `JJJJMM...'

   * `JJJJ*d|w...'

   * `JJJJ@e|DVAR...'

*Vorsicht:*
Falls der Datumteil mit weiteren Attributen ausgestattet ist und das
Jahr des Termin unbestimmt ist, d.h. das Jahr `JJJJ' ist auf Null
gesetzt, so werden solche Datumteile *nur* innerhalb einfacher
Jahresgrenzen korrekt berechnet, also nicht in denjenigen
Terminwarnungen, welche ausgegeben werden, nachdem das laufende Jahr
gewechselt hat, z.B.  in *Fiskaljahren*.

Listen von Tagen
................

Eine Liste von Tagen wird durch ein `,' Trennzeichens kenntlich gemacht;
diese muß mindestens zwei Elemente enthalten, und darf unbegrenzt viele
Elemente enthalten.  Ein einzelnes Element der Liste darf nicht auf den
Wert Null gesetzt werden und somit unkonkret sein, was in diesem
Zusammenhang auch keinen Sinn machen würde.

Eine Liste von Tagen wird dazu benutzt, um wiederkehrende Termine zu
definieren und dabei nur eine Zeile in der Ressourcendatei zu belegen,
anstelle diese wiederkehrenden Termine einzeln in mehreren Zeilen in
der Ressourcendatei festzulegen.  Angenommen ein Termin tritt stets am
1'ten und am 15'ten Tag in jedem beliebigen Monat des Jahres 1996 auf,
z.B.  `Steuer-Voranmeldungen', so kann einerseits für den 1'ten im
Monat ein Termineintrag in der Ressourcendatei vorgenommen werden und
auch für den 15'ten im Monat, was in diesem Fall zwei Einträge in der
Ressourcendatei zu einem solchen Termin ergäbe.

Andererseits kann mittels einer Liste von Tagen dieser Aufwand aber nun
verringert werden hin zu nur einen Eintrag in der Ressourcendatei,
welcher gleichermaßen für den 1'ten und für den 15'ten Tag eines
beliebigen Monat gilt, nämlich

     19960001,15 Steuer-Voranmeldungen

Erlaubt ist die Benutzung der Listen von Tagen im Datumteil wie folgt:

   * `JJJJMMTT|WWW|WWWN,[MM]TT|[MM]WWW|[MM]WWWN ...'

   * `JJJJ*d|wN|NWWW,N|NWWW ...'

   * `JJJJ@e|DVAR,|[+|-]N[WWW],[+|-]N[WWW] ...'

Einige Beispiele hierzu:

`000001fr3,12,99,mon,apr14,993,julfre3,08fr'
     In jedem Jahr im Monat Januar: am 3'ten Freitag, am 12'ten, am
     letzten Tag des Monats sowie an jedem Montag.  Und in jedem Jahr:
     am 14'ten April, am 3'ten Dezember, am 3'ten Freitag im Juli sowie
     an jedem Freitag im August.

`199600mon,fr,12'
     Im Jahr 1996 in jedem Monat: jeden Montag, jeden Freitag sowie an
     jedem 12'ten.

`0*d1,1fr,999,17mo'
     In jedem Jahr: am ersten Tag des Jahres, am 1'ten Freitag des
     Jahres, am letzten Tag des Jahres sowie am 17'ten Montag des
     Jahres.

`1996*w1fr,1,17mo,99fr'
     Im Jahr 1996: am Freitag der 1'ten ISO-Kalenderwoche, am Montag
     der ersten ISO-Kalenderwoche, am Montag der 17'ten
     ISO-Kalenderwoche sowie am Freitag der letzten ISO-Kalenderwoche.

`0@a,+1,-3,5,+4fr,2fr,-10sa'
     In jedem Jahr: am Datum der Datumvariablen A, einen Tag nach dem
     Datum von A, drei Tage vor dem Datum von A, fünf Tage nach dem
     Datum von A, vier Freitage nach dem Datum von A, zwei Freitage
     nach dem Datum von A sowie zehn Samstage vor dem Datum von A.

`1996@e+1,-3,5,+4fr,2fr,-10sa'
     Im Jahr 1996: einen Tag nach Ostersonntag, drei Tage vor
     Ostersonntag, fünf Tage nach Ostersonntag, vier Freitage nach
     Ostersonntag, zwei Freitage nach Ostersonntag sowie zehn Samstage
     vor Ostersonntag.

Bereiche von Tagen
..................

Ein Bereich von Tagen wird durch ein `#' Trennzeichens kenntlich gemacht
und besteht aus genau zwei Elementen, nämlich aus Starttag und
Endetag.  Der Starttag wie auch der Endetag des Bereichs darf nicht auf
den Wert Null gesetzt werden und somit unkonkret sein, was in diesem
Zusammenhang auch keinen Sinn machen würde.

Ein Bereich von Tagen wird ebenso wie eine Liste von Tagen dazu benutzt,
um wiederkehrende Termine zu definieren und dabei nur eine Zeile in der
Ressourcendatei zu belegen, anstelle diese wiederkehrenden Termine
einzeln in mehreren Zeilen in der Ressourcendatei festzulegen.
Angenommen ein Termin tritt stets während des 1'ten und des 15'ten
Tages (einschließlich) in jedem beliebigen Monat des Jahres 1996 auf,
z.B. `Innendienst', so kann einerseits für den 1'ten im Monat ein
Termineintrag in der Ressourcendatei vorgenommen werden, für den 2'ten
im Monat ebenso, bis hin zum 15'ten im Monat, was in diesem Fall 15
Einträge in der Ressourcendatei zu einem solchen Termin ergäbe
(einmal abgesehen von der Möglichkeit, daß in einem solchen Fall auch
eine Liste von Tagen verwendet werden kann).

Andererseits kann mittels eines Bereichs von Tagen dieser Aufwand aber
nun verringert werden hin zu nur einen Eintrag in der Ressourcendatei,
welcher gleichermaßen für den 1'ten bis hin zum 15'ten Tag eines
beliebigen Monat gilt, nämlich

     19960001#15 Innendienst

Erlaubt ist die Benutzung der Bereiche von Tagen im Datumteil wie folgt:

   * `JJJJMMWWW#WWW'

   * `JJJJMMTT|WWWN#[MM]TT|[MM]WWWN'

   * `JJJJ*d|wN[WWW]#N[WWW]'

   * `JJJJ@e|DVAR[[+|-]N[WWW]]#[+|-]N[WWW]'

Einige Beispiele hierzu:

`199600mon#fr'
     Im Jahr 1996 in jedem Monat: an jedem Tag, der in der Tagesfolge
     `mo, di, mi, do, fr' auftritt.

`000000fr#mon'
     In jedem Jahr in jedem Monat: an jedem Tag, der in der Tagesfolge
     `fr, sa, so, mo' auftritt.

`000001fr3#12'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 3'ten Freitag des Monats bis zum 12'ten des Monats fällt.

`00000112#fr3'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 12'ten des Monats bis zum 3'ten Freitag des Monats fällt.

`00000112#augfre3'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 12'ten Januar
     bis zum 3'ten Freitag des Monats August fällt.

`0000sep13#99fr9'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 13'ten
     September bis zum letzten Freitag des Monats Dezember fällt.

`0*d1#1fr'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 1'ten Tag des
     Jahres bis zum 1'ten Freitag des Jahres fällt.

`0*d99fr#333'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom letzten
     Freitag des Jahres bis zum 333'ten Tag des Jahres fällt.

`1996*w1fr#17mo'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Freitag der
     1'ten ISO-Kalenderwoche bis zum Montag der 17'ten
     ISO-Kalenderwoche fällt.

`0@a#+4fr'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom Datum der
     Datumvariablen A bis zum 4'ten Freitag nach dem Datum der
     Datumvariablen A fällt.

`1996@e-3#+9fr'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Datum drei
     Tage vor Ostersonntag bis zum 9'ten Freitag nach dem Datum des
     Ostersonntag fällt.

Wiederholungsfaktor von Tagen
.............................

Ein Wiederholungsfaktor von Tagen (`:N') wird durch ein `:' Zeichen
kenntlich gemacht und muß dem Tagesfeld, welches einen konkreten Wert
in einem Datumteil einer Gcal Ressourcendatei haben muß und nicht auf
den Wert Null gesetzt sein darf, folgen bzw. einem Auftretensfaktor von
Tagen entweder vorangehen oder folgen.  Mit Ausnahme von Bereichen von
Tagen oder Terminen, die nur an einem bestimmten Wochentag auftreten
wie z.B.  `199600mon Immer Montags 1996', darf ein solcher
Wiederholungsfaktor in allen ansonsten möglichen Angaben von
Datumteilen einer Gcal Ressourcendatei auftreten.

Dieser Faktor darf den Wert `1'...`999' annehmen.  Werte die größer
sind als die tatsächliche Differenz zwischen dem Datum des ersten
Auftretens des Termins und dem letzten Tag des Jahres werden stets auf
diese tatsächliche Differenz reduziert.  So bedeutet dann jeder Wert
größer `365' (oder `366' in Schaltjahren) stets einen
Wiederholungsfaktor bis hin zum letzten Tag des Jahres.

Ein Wiederholungsfaktor von Tagen wird dazu benutzt, um wiederkehrende
Termine zu definieren und dabei nur eine Zeile in der Ressourcendatei
zu belegen, anstelle diese wiederkehrenden Termine einzeln in mehreren
Zeilen in der Ressourcendatei festzulegen.  Angenommen ein Termin tritt
stets am 15'ten Tag in jedem beliebigen Monat des Jahres 1996 auf und
erstreckt sich über einen Zeitraum von insgesamt vier Tagen
(einschließlich des 15'ten selbst), z.B. `Mitarbeiterschulung', so
kann einerseits für den 15'ten im Monat ein Termineintrag in der
Ressourcendatei vorgenommen werden und auch für die dem 15'ten im
Monat folgenden drei Tage, was in diesem Fall vier Einträge in der
Ressourcendatei zu einem solchen Termin ergäbe (einmal abgesehen von
der Möglichkeit, daß in einem solchen Fall auch eine Liste oder ein
Bereich von Tagen verwendet werden kann).

Andererseits kann mittels eines Wiederholungsfaktors von Tagen dieser
Aufwand aber nun verringert werden hin zu nur einen Eintrag in der
Ressourcendatei, welcher gleichermaßen für den 15'ten und die dem
15'ten folgenden drei Tage eines beliebigen Monat gilt, nämlich

     19960015:4 Mitarbeiterschulung

Erlaubt ist die Benutzung der Wiederholungsfaktoren von Tagen im
Datumteil wie folgt:

   * `JJJJMMTT:N|WWWN:N'

   * `JJJJ*d|wN:N|NWWW:N'

   * `JJJJ@e|DVAR[[+|-]N[WWW]]:N'

   * `JJJJMMTT:N|WWWN:N,[MM]TT:N|[MM]WWWN:N ...'

   * `JJJJ*d|wN:N|NWWW:N,N:N|NWWW:N ...'

   * `JJJJ@e|DVAR:N,|[+|-]N[WWW]:N,[+|-]N[WWW]:N ...'

Einige Beispiele hierzu:

`000001fr3:11'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 3'ten Freitag des Monats und den darauffolgenden zehn Tagen
     fällt.

`00000112:3'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 12'ten des Monats und den darauffolgenden zwei Tagen fällt.

`00000112:3,fr3:5'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 12'ten des Monats und den darauffolgenden zwei Tagen fällt,
     sowie auch in den Zeitraum vom 3'ten Freitag des Monats und den
     darauffolgenden vier Tagen fällt.

`0*d1:1'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 1'ten Tag des
     Jahres und keinem darauffolgenden Tag fällt.

`0*d1:2'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 1'ten Tag des
     Jahres und dem darauffolgenden Tag fällt.

`0*d99fr:333'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom letzten
     Freitag des Jahres und den darauffolgenden 332 Tagen fällt.
     Allerdings werden in Fällen wie diesen, wo ein solcher Termin die
     Jahresgrenze überschreiten würde, nur Termine bis zum letzten
     Tag des Jahres produziert.

`1996*w1fr:17'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Freitag der
     1'ten ISO Kalenderwoche und den darauffolgenden 16 Tagen fällt.

`0@a:4'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom Datum der
     Datumvariablen A und den darauffolgenden drei Tagen fällt.

`1996@e-3:9'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Datum drei
     Tage vor Ostersonntag und den darauffolgenden acht Tagen fällt.

Auftretensfaktor von Tagen
..........................

Ein Auftretensfaktor von Tagen (`.N') wird durch ein `.' Zeichen
kenntlich gemacht und muß dem Tagesfeld, welches einen konkreten Wert
in einem Datumteil einer Gcal Ressourcendatei haben muß und nicht auf
den Wert Null gesetzt sein darf, folgen bzw. einem Wiederholungsfaktor
von Tagen entweder vorangehen oder folgen.  Mit Ausnahme von Terminen,
die nur an einem bestimmten Wochentag auftreten und als solche nicht
als ein Bereich von Tagen angegeben sind, wie z.B. `199600mon Immer
Montags 1996', darf ein solcher Wiederholungsfaktor in allen ansonsten
möglichen Angaben von Datumteilen einer Gcal Ressourcendatei
auftreten.  Bei Listen von Tagen darf dieser Faktor in jedem einzelnen
Element angegeben werden, bei Bereichen von Tagen darf dieser Faktor
*nur* dem Endetag folgen.  Allerdings macht die Verwendung dieses
Auftretensfaktors nur dann Sinn, wenn er entweder in einem Bereich von
Tagen, oder aber zusammen mit einem Wiederholungsfaktor angegeben wird.

Dieser Faktor darf den Wert `1'...`999' annehmen.  Wenn der Faktor
Werte annimmt, die größer sind als die tatsächliche Differenz
zwischen dem Datum des Auftretens des Termins und dem letzten Tag des
Jahres bzw. dem Ende des Zeitraum, für welchen die Termine entweder
produziert oder berücksichtigt werden sollen, so wird ein solcher
Termin ignoriert.

Ein Auftretensfaktor von Tagen wird dazu benutzt, um einem bestimmten
Versatz in wiederkehrenden Terminen zu definieren.  Angenommen ein
Termin tritt stets am 15'ten Tag in jedem beliebigen Monat des Jahres
1996 auf und erstreckt sich über einen Zeitraum von insgesamt sieben
Tagen (einschließlich des 15'ten selbst), soll aber nur jeden dritten
Tag (d.h. jeweils zwei Tage sind zu überspringen) innerhalb dieser
Periode berücksichtigt werden, z.B.  `Seminar', so kann einerseits
für den 15'ten im Monat ein Termineintrag in der Ressourcendatei
vorgenommen werden, für den 18'ten und auch für den 21'ten im Monat,
was in diesem Fall drei Einträge in der Ressourcendatei zu einem
solchen Termin ergäbe (einmal abgesehen von der Möglichkeit, daß in
einem solchen Fall auch eine Liste von Tagen verwendet werden kann).

Andererseits kann mittels eines Auftretensfaktors von Tagen dieser
Aufwand aber nun verringert werden hin zu nur einen Eintrag in der
Ressourcendatei, welcher gleichermaßen für den 15'ten, den 18'ten und
den 21'ten eines beliebigen Monat gilt, beispielsweise unter Verwendung
eines Wiederholungsfaktors

     19960015:7.3 Seminar

oder auch unter Verwendung eines Bereichs von Tagen

     19960015#21.3 Seminar

Erlaubt ist die Benutzung der Auftretensfaktoren von Tagen im Datumteil
wie folgt:

   * `JJJJMMTT:N.N|TT.N:N'

   * `JJJJMMWWWN:N.N|WWWN.N:N'

   * `JJJJ*d|wN:N.N|N.N:N'

   * `JJJJ*d|wNWWW:N.N|NWWW.N:N'

   * `JJJJ@e|DVAR[[+|-]N[WWW]]:N.N'

   * `JJJJ@e|DVAR[[+|-]N[WWW]].N:N'

   * `JJJJMMTT:N.N|WWWN:N.N,[MM]TT:N.N|[MM]WWWN:N.N ...'

   * `JJJJMMTT.N:N|WWWN.N:N,[MM]TT:N.N|[MM]WWWN.N:N ...'

   * `JJJJ*d|wN:N.N|NWWW:N.N,N:N.N|NWWW:N.N ...'

   * `JJJJ*d|wN.N:N|NWWW.N:N,N.N:N|NWWW.N:N ...'

   * `JJJJ@e|DVAR:N.N,|[+|-]N[WWW]:N.N,[+|-]N[WWW]:N.N ...'

   * `JJJJ@e|DVAR.N:N,|[+|.]N[WWW].N:N,[+|.]N[WWW].N:N ...'

   * `JJJJMMWWW#WWW.N'

   * `JJJJMMTT|WWWN#[MM]TT|[MM]WWWN.N'

   * `JJJJ*d|wN[WWW]#N[WWW].N'

   * `JJJJ@e|DVAR[[+|-]N[WWW]]#[+|-]N[WWW].N'

Einige Beispiele hierzu:

`000001fr3:11.3'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 3'ten Freitag und den darauffolgenden zehn Tagen fällt, aber
     nur jeden dritten Tag in diesem Zeitraum (überspringe jeweils
     zwei Tage).

`00000112:3.2'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 12'ten des Monats und den darauffolgenden zwei Tagen fällt,
     aber nur jeden zweiten Tag in diesem Zeitraum (überspringe jeweil
     einen Tag).

`00000112:3.2,fr3:5.3'
     In jedem Jahr im Monat Januar: an jedem Tag, der in den Zeitraum
     vom 12'ten des Monats und den darauffolgenden zwei Tagen fällt,
     aber nur jeden zweiten Tag (überspringe jeweils einen Tag) sowie
     auch am 3'ten Freitag im Januar jeden Jahres und den
     darauffolgenden vier Tagen, aber nur jeden dritten Tag
     (überspringe jeweils zwei Tage).

`0*d1:10.1'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 1'ten Tag des
     Jahres und den darauffolgenden neun Tagen fällt, und das für
     jeden dieser Tage (überspringe jeweils null Tage) in diesem
     Zeitraum.

`0*d1:2.5'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom 1'ten Tag des
     Jahres und dem darauffolgenden Tag fällt, aber nur jeden fünften
     Tag (überspringe jeweils vier Tage) in diesem Zeitraum.  In einem
     solchen Fall werden die dem Starttag (1'ter Tag des Jahres)
     folgenden Tage (in diesem Beispiel nur einer) nicht respektiert,
     da der nächste Tag, der sich unter Berücksichtigung des
     Auftretensfaktors ergibt, denjenigen Tag, welcher sich mit dem
     Wiederholungsfaktor als Endetag der Periode errechnet,
     überschreitet.

`0*d99fr:333.61'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom letzten
     Freitag des Jahres und den darauffolgenden 332 Tagen fällt, aber
     nur jeden 61'ten Tag (überspringe jeweils 60 Tage) in diesem
     Zeitraum.  Allerdings werden in Fällen wie diesen, wo ein solcher
     Termin die Jahresgrenze überschreiten würde, nur Termine bis zum
     letzten Tag des Jahres produziert.  Da nun aber mit einem Versatz
     von 60 Tage gearbeitet werden soll, wird keiner der dem Starttag
     (letzter Freitag des Jahres) folgenden Tage (in diesem Beispiel
     332) respektiert, da der nächste Tag, der sich unter
     Berücksichtigung des Auftretensfaktors ergibt, denjenigen Tag,
     welcher sich mit dem Wiederholungsfaktor als Endetag der Periode
     errechnet (hier wäre es der letzte Tag des Jahres),
     überschreitet.

`1996*w1fr:17.8'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Freitag der
     1'ten ISO-Kalenderwoche und den darauffolgenden 16 Tagen fällt,
     aber nur jeden achten Tag in diesem Zeitraum (überspringe jeweils
     sieben Tage).

`0@a:4.3'
     In jedem Jahr: an jedem Tag, der in den Zeitraum vom Datum der
     Datumvariablen A und den darauffolgenden drei Tagen fällt, aber
     nur jeden dritten Tag in diesem Zeitraum (überspringe jeweils
     zwei Tage).

`1996@e-3:9.4'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Datum drei
     Tage vor Ostersonntag und den darauffolgenden acht Tagen fällt,
     aber nur jeden vierten Tag in diesem Zeitraum (überspringe
     jeweils drei Tage).

`1996@e3#-20so.15'
     Im Jahr 1996: an jedem Tag, der in den Zeitraum vom Datum drei
     Tage nach Ostersonntag bis zum 20'ten Sonntag vor Ostersonntag
     fällt, aber nur jeden 15'ten Tag in diesem Zeitraum (überspringe
     jeweils 14 Tage).

Textteil einer Zeile
--------------------

Der "Textteil" einer Zeile der Ressourcendatei darf jeden beliebigen
Text enthalten den Sie mögen.  Falls der Textteil nicht von Gcal
selbst erzeugte Zeichen zur Druckaufbereitung oder Hervorhebung
enthält oder Zeichen, denen in der Tabelle des verwendeten
Zeichensatzes ein Wert größer 127 (dezimal) zugeordnet ist (diese
sind evtl. nicht druckbar), so werden auch diese Zeichen von Gcal
ausgegeben, allerdings *uninterpretiert*!  Deswegen können bei der
Ausgabe solcher Zeichen unter Umständen Probleme mit der verwendeten
Bildschirmtreiber Software und/oder dem externen Paginiererprogramm
auftreten, ebenso wie beim Versand solcher Zeichen mittels
elektronischer Post.

Sogenannte `NUL' Zeichen (das ist das Zeichen, welchem in der Tabelle
des verwendeten Zeichensatzes der Wert Null zugeordnet ist) dürfen
auch im Textteil enthalten sein, diese bewirken aber, daß der gesamte
Text, der dem ersten Auftreten von einem `NUL' Zeichen folgt,
unterdrückt wird.  Da es meiner Meinung nach keinen erkennbaren Sinn
macht auch diese Zeichen als solche uninterpretiert auszugeben, dienen
diese also nur zum kommentieren; ansonsten würden `NUL' Zeichen auch
die bereits vorgenannten Probleme verursachen.

Eine Zeile der Ressourcendatei wird auf der Folgezeile fortgesetzt, wenn
eine `\-\n' (Backslash-Newline) Zeichensequenz vorgefunden wird, d.h.
das Newline Zeichen der Zeile durch ein Backslash Zeichen unterdrückt
wird, z.B.:

Die Zeile:
     000000Mo Jeden Montag

und die Zeilen:
     000000Mo \
     Jeden \
     Montag

bewirken die gleiche Ausgabe und sind insofern identisch.

Ferner können *lange* Textzeilen aus der Ressourcendatei an beliebiger
Stelle umgebrochen werden.  Die Bezeichnung *lang* bedeutet in diesem
Zusammenhang, daß der von Gcal bei der Ausgabe dargestellte Text den
rechten Bildschirmrand überschreiten bzw. an diesem umgebrochen
würde.  Jedesmal wenn ein `~' (Tilde) Zeichen im Textteil vorgefunden
wird, so wird dieses Zeichen durch ein echtes `\n' (Newline) Zeichen
ersetzt und der so umgebrochene Text bei der Ausgabe linksbünding
formatiert dargestellt.

Falls das `~' (Tilde) Zeichen als Zeichen selbst verwendet werden soll,
so muß es durch ein führendes `\' (Backslash) Zeichen quotiert werden,
z.B. `\~'.

Wenn die Zeichen `\~' selbst als Zeichenfolge verwendet werden sollen,
so muß das `\' (Backslash) Zeichen mit sich selbst quotiert werden,
z.B. `\\~'.

Die Ressourcendatei `beispiel.rc'

     ;
     ; Hallo, ich bin `beispiel.rc' und jetzt lebendig
     ;
     0 Ich weiss ich bin ein kurzer Text
     0 Ich hoffe ich bin lang genug~hier, ein Zeilenumbruch\
     ~und noch einer~und nun zum letzten Mal...
     0 Bin ich ein kurzer Text? Weiss nicht...

wird wie folgt ausgegeben:

     $ gcal --resource-file=beispiel.rc --disable-highlighting
     -|
     -| Terminliste:
     -|
     -| Mi,  14 Sep 1994: Bin ich ein kurzer Text? Weiss nicht...
     -| Mi,  14 Sep 1994: Ich hoffe ich bin lang genug
     -|                   hier, ein Zeilenumbruch
     -|                   und noch einer
     -|                   und nun zum letzten Mal...
     -| Mi,  14 Sep 1994: Ich weiss ich bin ein kurzer Text

Da *whitespace* Zeichen zur Trennung von Datum- und Textteil verwendet
werden, ist es somit nicht ohne weiteres möglich den Textteil mit
führenden *whitespace* Zeichen zu versehen, weil diese intern
übersprungen werden und somit nicht zur Ausgabe gelangen.  Falls nun
aber doch *whitespace* Zeichen den Textteil anführen sollen, so muß
das *erste* dieser *whitespace* Zeichen durch ein führendes `\'
(Backslash) Zeichen quotiert werden, z.B. `\ ', wenn es sich um ein
Leerzeichen handelt.  Gcal erkennt an Hand einer solchen Zeichenfolge,
daß der Text, der dem `\' Zeichen nachfolgt, nicht mehr länger der
Trennung dient, sondern Bestandteil vom Textteil ist.  Gcal
überspringt sodann dieses besondere, nur der Markierung dienende
Backslash Zeichen (stellt es also nicht in die Ausgabe), und
verarbeitet den Rest der Zeile wie üblich.

Folgendes Beispiel sollte genügen um den vorstehenden Sachverhalt zu
verdeutlichen.  Die Ressourcendatei `whitespc.rc'

     0 BANG BANG
     0 bogus
     0         bogomips
     0    \hallo welt
     0    \ main(){for(;;)fork();}
     0 \     sh $0 & $0 &
     0    \  a  \  b  \\  c  \\\  d
     0    Was passiert nun?\
     ~0  \  Dieses!
     0    Was passiert nun?\\
     ~0  \  Jenes!

wird wie folgt ausgegeben:

     $ gcal --resource-file=whitespc.rc --disable-highlighting
     -|
     -| Terminliste:
     -|
     -| Mi,  14 Sep 1994:      sh $0 & $0 &
     -| Mi,  14 Sep 1994:   a  \  b  \\  c  \\\  d
     -| Mi,  14 Sep 1994:  main(){for(;;)fork();}
     -| Mi,  14 Sep 1994: BANG BANG
     -| Mi,  14 Sep 1994: Was passiert nun?~0  \  Jenes!
     -| Mi,  14 Sep 1994: Was passiert nun?
     -|                   0  \  Dieses!
     -| Mi,  14 Sep 1994: \hallo welt
     -| Mi,  14 Sep 1994: bogomips
     -| Mi,  14 Sep 1994: bogus

Zeile kommentieren
------------------

Eine Zeile der Ressourcendatei, die mit einem `;' (Semikolon) Zeichen
beginnt, ist ein Kommentar und wird von Gcal vollständig ignoriert!
Führende *whitespace* Zeichen dürfen dem Kommentarzeichen vorangehen.
Siehe in diesem Zusammenhang auch *Siehe Textteil einer Zeile::, wo
erklärt wird, wie ein `NUL' Zeichen zur Kommentierung in einem
Textteil benutzt werden kann.

Include Anweisungen
-------------------

Es dürfen `#include' Anweisungen in einer Ressourcendatei eingefügt
werden (ein Mechanismus ähnlich demjenigen, den der C Preprocessor
benutzt), welche daß Aufsuchen und Vorladen weiterer Ressourcendateien
bewirken.  Eine `#include' Anweisung veranlasst Gcal das Lesen der
laufenden Ressourcendatei zu unterbrechen und eine andere
Ressourcendatei zu lesen, bevor mit dem Weiterlesen der laufenden
Ressourcendatei fortgefahren wird.  Die Anweisung ist eine Zeile in der
Ressourcendatei, die wie die folgende Schablone aussieht:

     #include *whitespace* ARGUMENT [*whitespace*] *newline*

Das ARGUMENT kann entweder

     "DATEINAME"

oder

     <DATEINAME>

sein (also ein Dateiname, der entweder mit `""' oder `<>' umfasst ist).

Mindestens ein *whitespace* Zeichen ist notwending zwischen `#include'
und dem ARGUMENT.  Dem ARGUMENT dürfen beliebig viele *whitespace*
Zeichen folgen und die Zeile muß mit einem `\n' (Newline) Zeichen
enden, ausgenommen es ist die letzte Zeile in einer Ressourcendatei.

Nun zu einem etwas konkreteren Beispiel:

  1. #include "foo/bar"

  2. #include <bar>

Die erste `#include' Anweisung regt Gcal an, die Datei `bar' im
Dateiverzeichnis `foo' vom aktuellen Dateiverzeichnis aus einzufügen.
Falls das nicht gelingt, versucht Gcal mittels der Schritte 1...4 des
bereits zuvor erklärten Datei-Suchmechanismus' diese Datei einzufügen
(*siehe Datei-Suchmechanismus: Ressourcendatei.).

Die zweite `#include' Anweisung regt Gcal an, die Datei `bar' aus dem
Benutzer- bzw. System-Datenverzeichnis mittels der Schritte 3...4 des
bereits zuvor erklärten Datei-Suchmechanismus' einzufügen.
Allerdings ist es nicht gestattet Dateien, deren Zugriffspfad vom
Wurzeldateiverzeichnis aus fest vorgegeben ist, mittels einer solchen
`#include' Anweisung einzufügen, wie z.B.: `#include </file>' oder
`#include </foo/bar/file>'.  Ebenfalls nicht gestattet ist die Angabe
eines einfachen oder erweiterten Dateinamens, der mit einer
Laufwerksangabe versehen ist bei dieser Art von `#include' Anweisungen
(auch wenn ein Betriebssystem wie MS-DOS oder OS/2 eine solche
Laufwerksangabe grundsätzlich erlauben würde), da der mit führendem
Benutzer- bzw. System-Datenverzeichnisnamen ausgestattete resultierende
erweiterte Dateiname nicht mehr den geltenden Dateinamenskonventionen
entsprechen würde.

Eingefügte Dateien dürfen ihrerseits wiederum weitere Dateien
einfügen.  Allerdings ist die Schachtelungstiefe eingefügter Dateien
einerseits durch die Größe des zur Verfügung stehenden
Hauptspeichers begrenzt, und andererseits durch den Wert, der vom
Betriebssystem bzw. Kompilierer als Obergrenze von gleichzeitig
geöffneten Dateien vorgegeben ist.  Rekursive Einfügungen (1) oder
zyklische Einfügungen (2) sind nicht erlaubt, da solche
Rückwärtsbezüge eine programminterne Endlosschleife erzeugen würden!
Gcal erkennt solche Situationen und beendet sich sofort mit einem
fatalen Fehler.

Falls eine eingefügte Ressourcendatei nicht gefunden wurde und keine
`--debug=abort' Option angegeben wurde, so wird mit der Verarbeitung
der Ressourcendatei, welche `#include' enthielt, fortgefahren.

  ---------- Fussnoten ----------

  (1)  Die eingefügte Datei versucht sich selbst erneut einzufügen.

  (2)  Die eingefügte Datei wird von einer anderen Datei, die an einer
tieferen Stelle in einer solchen Kette auftritt, erneut eingefügt.

Spezielle Textmakros
--------------------

Der Textteil einer Zeile der Ressourcendatei darf 16 verschiedene,
spezielle Textmakros enthalten, welche in jeder (sinnvollen) beliebigen
Anzahl und Reihenfolge auftreten dürfen.  Diese Texte beginnen alle
mit dem `%' (Prozent) Zeichen, welches seinerseits durch ein führendes
`\' (Backslash) Zeichen hinsichtlich seiner speziellen Bedeutung
entwertet (quotiert) werden kann, falls das `%' (Prozent) Zeichen
selbst im Textteil verwendet werden soll, z.B. `\%'.  Dem `%' Zeichen
folgt sodann ein Kennzeichen, welches die Art des Textmakros definiert.
Falls das Kennzeichen ein Buchstabe ist, so wird nicht zwischen Groß-
bzw. Kleinschreibung unterschieden.

     *Bitte beachten:*
     Das optionale Datum nach den `%s...', `%e...', `%o...', `%k...',
     `%b...' und `%y...' Textmakros darf entweder im
     `JJJJ[MM[TT|WWWN]]', `JJJJ*d|wN[WWW]' oder
     `JJJJ@e|DVAR[[+|-]N[WWW]]' Datumformat angegeben werden.

%s Textmakro
............

`%s[JJJJ[MM[TT|WWWN]]]' bezeichnet das "Startdatum" eines Termins, d.h.
das erste Datum, an dem dieser Termin auftreten darf.  Wenn das Datum,
welches im `%s...' Textmakro kodiert ist, größer dem laufenden bzw.
abgefragten Datum ist, so wird der gesamte Warnungstext unterdrückt.
Wenn der Warnungstext angezeigt werden muß, so wird stets der gesamte
Text dieses Makros bei der Ausgabe unterdrückt.  Diesem Textmakro
*muß* stets ein *whitespace* Zeichen folgen, welches in der Ausgabe
entfernt wird.

   * Falls JJJJ... nicht angegeben ist (==*kein* Datum kodiert), so
     wird der 01 Januar des laufenden Jahres als Datum angenommen.

   * Falls JJJJ auf den Wert 0000 gesetzt ist, so wird das laufende Jahr
     als Jahr angenommen.

   * Falls MM nicht angegeben ist, so wird 01 (==Januar) als Monat
     angenommen.

   * Falls MM auf den Wert 00 gesetzt ist, so wird der laufende Monat
     als Monat angenommen.

   * Falls TT|WWW nicht angegeben ist, so wird 01 als Tag angenommen.

   * Falls TT auf den Wert 00 gesetzt ist, so wird der laufende Tag als
     Tag angenommen.

   * Falls das N Feld angegeben ist (Bereich 1...5 oder 9), so muß
     auch ein WWW Feld angegeben sein.

%e Textmakro
............

`%e[JJJJ[MM[TT|WWWN]]]' bezeichnet das "Endedatum" eines Termins, d.h.
das letzte Datum, an dem dieser Termin auftreten darf.  Wenn das Datum,
welches im `%e...' Textmakro kodiert ist, kleiner dem laufenden bzw.
abgefragten Datum ist, so wird der gesamte Warnungstext unterdrückt.
Wenn der Warnungstext angezeigt werden muß, so wird stets der gesamte
Text dieses Makros bei der Ausgabe unterdrückt.  Diesem Textmakro
*muß* stets ein *whitespace* Zeichen folgen, welches in der Ausgabe
entfernt wird.

   * Falls JJJJ... nicht angegeben ist (==*kein* Datum kodiert), so
     wird der 31 Dezember des laufenden Jahres als Datum angenommen.

   * Falls JJJJ auf den Wert 0000 gesetzt ist, so wird das laufende Jahr
     als Jahr angenommen.

   * Falls MM nicht angegeben ist, so wird 12 (==Dezember) als Monat
     angenommen.

   * Falls MM auf den Wert 00 gesetzt ist, so wird der laufende Monat
     als Monat angenommen.

   * Falls TT|WWW nicht angegeben ist, so wird der letzte Tag des
     Monats MM als Tag angenommen.

   * Falls TT auf den Wert 00 gesetzt ist, so wird der laufende Tag als
     Tag angenommen.

   * Falls das N Feld angegeben ist (Bereich 1...5 oder 9), so muß
     auch ein WWW Feld angegeben sein.

%o Textmakro
............

`%o[JJJJ[MM[TT|WWWN]]]' bezeichnet einen "Wochentagsnamen" und wird in
einen *Wochentagstext* umgesetzt, z.B.:

     Der Text `Heute ist %o , der %n' wird umgesetzt in
     ==> `Heute ist Montag, der 10-Jun-1996', falls das aktuelle Datum
     der 10'te Juni 1996 ist.

Wenn der Warnungstext angezeigt werden muß, so wird stets der gesamte
Text dieses Makros bei der Ausgabe unterdrückt.  Diesem Textmakro
*muß* stets ein *whitespace* Zeichen folgen, welches in der Ausgabe
entfernt wird.

   * Falls JJJJ... nicht angegeben ist (==*kein* Datum kodiert), so
     wird laufende Datum als Datum angenommen.

   * Falls JJJJ auf den Wert 0000 gesetzt ist, so wird das laufende Jahr
     als Jahr angenommen.

   * Falls MM nicht angegeben oder auf den Wert 00 gesetzt ist, so wird
     der laufende Monat als Monat angenommen.

   * Falls TT|WWW nicht angegeben oder auf den Wert 00 gesetzt ist, so
     wird der laufende Tag als Tag angenommen.

   * Falls das N Feld angegeben ist (Bereich 1...5 oder 9), so muß
     auch ein WWW Feld angegeben sein.

%k Textmakro
............

`%k[JJJJ[MM[TT|WWWN]]]' bezeichnet eine "Wochennummer" und wird in einen
ISO-*Wochennummer-Text* umgesetzt, z.B.:

     Der Text `Heute ist %o  der Kalenderwoche %k' wird umgesetzt in
     ==> `Heute ist Montag der Kalenderwoche 24', falls das aktuelle
     Datum der 10'te Juni 1996 ist.

Wenn der Warnungstext angezeigt werden muß, so wird stets der gesamte
Text dieses Makros bei der Ausgabe unterdrückt.  Diesem Textmakro
*muß* stets ein *whitespace* Zeichen folgen, welches in der Ausgabe
entfernt wird.

   * Falls JJJJ... nicht angegeben ist (==*kein* Datum kodiert), so
     wird laufende Datum als Datum angenommen.

   * Falls JJJJ auf den Wert 0000 gesetzt ist, so wird das laufende Jahr
     als Jahr angenommen.

   * Falls MM nicht angegeben oder auf den Wert 00 gesetzt ist, so wird
     der laufende Monat als Monat angenommen.

   * Falls TT|WWW nicht angegeben oder auf den Wert 00 gesetzt ist, so
     wird der laufende Tag als Tag angenommen.

   * Falls das N Feld angegeben ist (Bereich 1...5 oder 9), so muß
     auch ein WWW Feld angegeben sein.

%b Textmakro
............

`%b[JJJJ[MM[TT|WWWN]]]' bezeichnet ein "Geburtsjahr" und wird in einen
*Alterswert* umgesetzt, z.B.:

     Der Text `Mein %b1962  Geburtstag%s1952 %e2062' wird umgesetzt in
     ==> `Mein 32 Geburtstag', falls das aktuelle Jahr 1994 ist.

Der Alterswert wird nur dann ausgegeben, wenn sich bei dessen Berechnung
ein Wert größer Null ergibt.  Zudem wird die Terminwarnung in diesem
vorangehenen Beispiel nur während der Jahre 1952 bis 2062
(einschließlich) ausgegeben.  Wenn der Warnungstext angezeigt werden
muß, so wird stets der gesamte Text dieses Makros bei der Ausgabe
unterdrückt.  Diesem Textmakro *muß* stets ein *whitespace* Zeichen
folgen, welches in der Ausgabe entfernt wird.  Falls im verwendeten
Datumformat vereinbart wurde, daß bei der Ausgabe von einem Datum auch
ein Ordnungszahlanhang verwendet werden soll, so wird auch der
ermittelte Alterswert automatisch mit einem nachfolgenden
Ordnungszahlanhang versehen.  *Siehe `--date-format=de|us|gb|TEXT':
Kalender Optionen, für weitere Details.

   * Falls JJJJ... nicht angegeben ist (==*kein* Datum kodiert), so
     wird laufende Datum als Datum angenommen.

   * Falls JJJJ auf den Wert 0000 gesetzt ist, so wird das laufende Jahr
     als Jahr angenommen.

   * Falls MM nicht angegeben oder auf den Wert 00 gesetzt ist, so wird
     der laufende Monat als Monat angenommen.

   * Falls TT|WWW nicht angegeben oder auf den Wert 00 gesetzt ist, so
     wird der laufende Tag als Tag angenommen.

   * Falls das N Feld angegeben ist (Bereich 1...5 oder 9), so muß
     auch ein WWW Feld angegeben sein.

%y Textmakro
............

`%y[JJJJ[MM[TT|WWWN]]]' bezeichnet jedwedes Jahr und wird in einen
"Jahresdifferenzenwert" umgesetzt, z.B.:

     Der Text `Silvester 1912 liegt %y1912  Jahre zurück' wird
     umgesetzt in
     ==> `Silvester 1912 liegt -82 Jahre zurück', falls das aktuelle
     Jahr 1994 ist.

Wenn der Warnungstext angezeigt werden muß, so wird stets der gesamte
Text dieses Makros bei der Ausgabe unterdrückt.  Diesem Textmakro
*muß* stets ein *whitespace* Zeichen folgen, welches in der Ausgabe
entfernt wird.

   * Falls JJJJ... nicht angegeben ist (==*kein* Datum kodiert), so
     wird laufende Datum als Datum angenommen.

   * Falls JJJJ auf den Wert 0000 gesetzt ist, so wird das laufende Jahr
     als Jahr angenommen.

   * Falls MM nicht angegeben oder auf den Wert 00 gesetzt ist, so wird
     der laufende Monat als Monat angenommen.

   * Falls TT|WWW nicht angegeben oder auf den Wert 00 gesetzt ist, so
     wird der laufende Tag als Tag angenommen.

   * Falls das N Feld angegeben ist (Bereich 1...5 oder 9), so muß
     auch ein WWW Feld angegeben sein.

%m Textmakro
............

`%m' bezeichnet die laufende bzw. abgefragte "Monatsnummer" relativ zum
aktuellen (==heutigen) Datum.

%w Textmakro
............

`%w' bezeichnet die laufende bzw. abgefragte "Wochennummer" relativ zum
aktuellen (==heutigen) Datum.

%d Textmakro
............

`%d' bezeichnet die laufende bzw. abgefragte "Tagesnummer" relativ zum
aktuellen (==heutigen) Datum, z.B.:

     Die Ressourcendateizeile `0 %d Tage vergangen' wird umgesetzt in
     ==> `-10 Tage vergangen', falls Gcal mit der Option `-c10-' und
     keinem Kommando aufgerufen wird.

%j Textmakro
............

`%j[[-]N]' bezeichnet die laufende bzw. abgefragte "Julianische
Tageszahl" relativ zum aktuellen (==heutigen) Datum.  Diese Tageszahl
bezieht sich auf das Datum 1'ter Januar 4713 vor Christus, welches für
astronomische Berechnungen als der Tag Null einer durchlaufenden
Tageszählung angesehen wird und als das Julianisches Datum (J.D.)
bekannt ist.  Der exakte Nullpunkt von diesem Datum ist um 12 Uhr
Weltzeit; der Tageswechsel erfolgt also nicht um Mitternacht, sondern
um Mittag Weltzeit.  Da Gcal derzeit nicht die Zeitzone des vom Rechner
gelieferten Systemdatum auswertet, wird diese Tageszahl nur ganzzahlig
dargestellt in der Annahme, daß der Tageswechsel bereits Mittags
stattgefunden hat.  Wer den Tageswechsel als Mittags noch nicht bereits
vollzogen haben möchte, der soll die sich aus dem Textmakro ergebende
Julianische Tageszahl stets um den Faktor eins vermindern, z.B. `%j-1'.

Beispiel:

     Die Ressourcendateizeile
     `0 Julianischer Tag %j seit 01-Jan-4713 v.Chr.' wird umgesetzt in
     ==> `Julianischer Tag 2437929 seit 01-Jan-4713 v.Chr.', falls Gcal
     mit den Optionen `-c %19620921' sowie keinem Kommando aufgerufen
     wird.

Wenn dem `%j' Text eine Zahl direkt folgt, so wird diese Zahl von der
tatsächlichen Julianischen Tageszahl stets subtrahiert (ein negatives
Vorzeichen kann der besseren Lesbarkeit wegen angegeben werden), so
daß im Text mit beliebigen Bezugsgrößen gearbeitet werden kann, z.B.:

     Die Ressourcendateizeile
     `0 Julianischer Tag %j-2415021 seit 01-Jan-1900' wird umgesetzt in
     ==> `Julianischer Tag 4 seit 01-Jan-1900', falls Gcal mit den
     Optionen `-c %19000105' sowie keinem Kommando aufgerufen wird.

%n Textmakro
............

`%n[[+|-]N]' bezeichnet die laufende bzw. abgefragte "Tagesnummer"
relativ zum laufenden Datum `+/-' N Tagen und wird in einen, sich auf
ein absolutes Datum beziehenden "Datumtext" umgesetzt, z.B.:

     Die Ressourcendateizeile `1962Sep21 10000 Tage alt: %n+10000' wird
     umgesetzt in
     ==> `10000 Tage alt: 06-Feb-1990', falls Gcal mit der einfachen
     `-c' Option und dem `sep 1962' Kommando aufgerufen wird (*siehe `MM
     JJJJ': Einfache Kommandos.).

%t Textmakro
............

`%t[12|24]' bezeichnet die "aktuelle Systemuhrzeit", z.B.:

     Der Text `Uhrzeit: %t --> Zahnarzttermin um 10.00 Uhr' wird
     umgesetzt in
     ==> `Uhrzeit: 07.32 --> Zahnarzttermin um 10.00 Uhr', falls die
     aktuelle Systemuhrzeit 07.32 Uhr (hh.mm) ist.

Der Systemuhrzeitwert wird standardgemäß im *24-Stunden* Format
ausgegeben.  Um im *12-Stunden* Format auszugeben, muß hinter `%t' die
Zahl `12' geschrieben werden, z.B. `%t12'.

%1 Textmakro
............

`%1' wird ersetzt durch die Start Hervorhebungssequenz bzw. das Start
Markierungszeichen, welches zur Hervorhebung des aktuellen Tages
benutzt wird (*siehe `--highlighting=TEXT': Globale Optionen.).  Damit
wird erreicht, daß der diesem Textmakro nachfolgende Text der Zeile in
gleicher Weise ausgegeben wird, wie der hervorgehobene bzw. markierte
aktuelle Tag.  `%1' wird in Verbindung mit dem `%2' Textmakro benutzt,
welches die mit `%1' eingeschaltete Hervorhebung wieder ausschaltet
bzw. ein Ende Markierungszeichen produziert.  Sollte einem `%1' Text
kein `%2' Text auf der Zeile nachfolgen, so fügt Gcal automatisch
einen solchen `%2' Text am Zeilenende ein.

Zum Beispiel:

     In dieser Zeile wird nur %1DIESES%2 Wort hervorgehoben.
     %1In dieser Zeile wird alles bis hierhin%2 hervorgehoben.
     Alles ab %1hier bis zum Zeilenende wird hervorgehoben.

%2 Textmakro
............

`%2' wird ersetzt durch die Ende Hervorhebungssequenz bzw. das Ende
Markierungszeichen, welches zur Hervorhebung des aktuellen Tages
benutzt wird.  Damit wird erreicht, daß ab der Stelle des Auftretens
dieses Textmakros eine möglicherweise aktive Hervorhebung entsprechend
der des aktuellen Tages wieder abgeschaltet bzw. ein Ende
Markierungszeichen produziert wird.  `%2' wird in Verbindung mit dem
`%1' Textmakro benutzt.  Sollte vor einem `%2' Text kein `%1' Text auf
der Zeile vorgefunden werden, so hat der `%2' Text keinerlei Wirkung.

%3 Textmakro
............

`%3' wird ersetzt durch die Start Hervorhebungssequenz bzw. das Start
Markierungszeichen, welches zur Hervorhebung eines Feiertages benutzt
wird (*siehe `--highlighting=TEXT': Globale Optionen.).  Damit wird
erreicht, daß der diesem Textmakro nachfolgende Text der Zeile in
gleicher Weise ausgegeben wird, wie ein hervorgehobener bzw. markierter
Feiertag.  `%3' wird in Verbindung mit dem `%4' Textmakro benutzt,
welches die mit `%3' eingeschaltete Hervorhebung wieder ausschaltet bzw.
ein Ende Markierungszeichen produziert.  Sollte einem `%3' Text kein
`%4' Text auf der Zeile nachfolgen, so fügt Gcal automatisch einen
solchen `%4' Text am Zeilenende ein.

Zum Beispiel:

     In dieser Zeile wird nur %3DIESES%4 Wort hervorgehoben.
     %3In dieser Zeile wird alles bis hierhin%4 hervorgehoben.
     Alles ab %3hier bis zum Zeilenende wird hervorgehoben.

%4 Textmakro
............

`%4' wird ersetzt durch die Ende Hervorhebungssequenz bzw. das Ende
Markierungszeichen, welches zur Hervorhebung eines Feiertages benutzt
wird.  Damit wird erreicht, daß ab der Stelle des Auftretens dieses
Textmakros eine möglicherweise aktive Hervorhebung entsprechend der
eines Feiertages wieder abgeschaltet bzw. ein Ende Markierungszeichen
produziert wird.  `%4' wird in Verbindung mit dem `%3' Textmakro
benutzt.  Sollte vor einem `%4' Text kein `%3' Text auf der Zeile
vorgefunden werden, so hat der `%4' Text keinerlei Wirkung.

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

Gcal respektiert *globale* und/oder *lokale* Datumvariablen, welche
entweder im Datumteil einer Zeile der Gcal Ressourcendatei oder als
Bestandteil eines speziellen Textmakros im Textteil einer Zeile der
Ressourcendatei verwendet werden dürfen.  *Siehe
`--date-variable=ARGUMENT': Terminwarnung Optionen.  Das bedeutet, daß
bis zu *25* benutzerdefinierte Datumvariablen gesetzt und während der
Programmausführung referenziert werden können.  Der Name einer
Datumvariablen DVAR besteht aus einem einzelnen Buchstaben (Groß- bzw.
Kleinbuchstaben werden nicht unterschieden und ausgenommen dem
Buchstaben `e', welcher intern für das Datum des Ostersonntags
reserviert ist und welcher deswegen nicht zuweisbar/inoperabel ist),
und wird bei einer Definition gefolgt von dem Zuweisungsoperator `='
und den Zahlenwerten für Monat MM (oder einem Monatsnamen im
dreistelligen Kurzformat, z.B. `Jan', `Feb', ...) und Tag TT, welche
diese Variable aufzunehmen hat (oder dem Namen einer anderen
Datumvariablen), 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, die im `MMWWWN',
`DVAR[+|-]N[WWW]' oder `*d|wN[WWW]' Format angegeben werden, zugewiesen
werden, 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 ISO-Kalenderwoche fällt,
zugewiesen.

*Achtung:*
Diese Art der Zuweisung an Datumvariablen wird *nur* innerhalb einfacher
Jahresgrenzen korrekt berechnet, also nicht in denjenigen
Terminwarnungen, 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 nicht bei
Rückkehr zur aufrufenden Datei exportiert werden.  Alle anderen
Definitionen von Datumvariablen (in der Kommandozeile,
Umgebungsvariable `GCAL' oder Antwortdatei) 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 Warnungstext für jede undefinierte
Datumvariable ausgegeben (*siehe `--debug=internal': Globale Optionen.).
Falls die `--debug=abort' Option angegeben wurde, so wird Gcal das
Programm dann abbrechen, sobald die erste Referenz einer undefinierten
Datumvariablen auftritt.  Für weitere Informationen, siehe auch *Siehe
`--debug=abort': Globale Optionen.

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.rc'
verdeutlicht diesen Sachverhalt:

     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 folgende Ausgabe:

     $ gcal %1777 -H no -x -v z=1212 -f ./dvar.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.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.  *Siehe Include Anweisungen::, 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 Handhabung 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 bewirken wollen; *Sie seien nun
ausdrücklich gewarnt!*

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

`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 (diese werden nur lokal ausgeführt),
nicht 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 oder Operation
auf eine Datumvariable in einer separaten Zeile der Ressourcendatei
erfolgen muß.

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

Gcal respektiert *globale* und/oder *lokale* Textvariablen, welche
überall in einer Zeile der Gcal Ressourcendatei verwendet werden
dürfen.  *Siehe `--text-variable=ARGUMENT': Terminwarnung Optionen.  Das
bedeutet, daß bis zu *26* benutzerdefinierte Textvariablen gesetzt und
während der Programmausführung referenziert werden können.  Der Name
einer Textvariablen "tvar" besteht aus einem `$' Präfix und einem
einzelnen Buchstaben (Groß- bzw. Kleinbuchstaben werden nicht
unterschieden), und wird in einer Definition gefolgt von dem
Zuweisungsoperator `=' und dem Text, welchen diese Variable aufzunehmen
hat.  Nur lokale Textvariablen werden auf einen undefinierten Wert
gesetzt falls kein Text rechts des Zuweisungsoperators angegeben ist.
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.

Falls das `$' Zeichen im Text als Zeichen selbst verwendet werden soll,
so muß dieses durch ein führendes `\' (Backslash) Zeichen quotiert
(geschützt/entwertet) werden, z.B. `\$'.

Wenn die Zeichen `\$' im Text selbst als Zeichenfolge verwendet werden
sollen, so muß das `\' (Backslash) Zeichen mit sich selbst quotiert
werden, z.B. `\\$'.

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

     $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 ./demo.rc
     -|
     -| 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:    \ \\ Und das... geht auch!
     -| Mo,   1 Jan 1996: foo bar foo foo frozz FROBOZZ frozz --> Das ist $b
     -| Mo,   1 Jan 1996: $x='' und $d ist nicht definiert: $d...

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

     $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 ./demo2.rc
     -|
     -| Mo,   1 Jan 1996: $a:0@e foo
     -| Mo,   1 Jan 1996: $b:0@e
     $ gcal %19960101 -H no -x -f ./demo2.rc -y
     -|
     -| So,   7 Apr 1996: $b
     -| So,   7 Apr 1996: foo bar

Wie zuvor gesehen können vollständige (oder auch teilweise) Datumteile
(*siehe Datumteil einer Zeile::.), sowie spezielle Textmakros (*siehe
Spezielle Textmakros::.) in Textvariablen angegeben werden, oder auch
Referenzen auf andere Textvariablen, welche nach Expansion der
Textvariablen von Gcal verarbeitet werden.

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 nicht bei
Rückkehr zur aufrufenden Datei exportiert werden.  Alle anderen
Definitionen von Textvariablen (in der Kommandozeile, Umgebungsvariable
`GCAL' oder Antwortdatei) 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.

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.  *Siehe Include Anweisungen::, 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 Handhabung 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 bewirken wollen; *Sie seien nun
ausdrücklich gewarnt!*

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 Definitionen nur in dieser
entsprechenden Datei gültig (diese werden nur lokal ausgeführt),
nicht 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 in einer separaten Zeile der Ressourcendatei erfolgen muß.

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

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

Zunächst ein ganz allgemeines Beispiel:

     ; Das ist ein allgemeines Beispiel einer Ressourcendatei.
     ;
     19940715 Uhrzeit: %t --> Zahnarzttermin um 10:00 Uhr
     00000921 Mein %b1962 Geburtstag%s1962 %e2062
     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 dritte Montag im Juli~jeden Jahres kleiner 1980%e1979
     0000@e-10 Ostersonntag-10 Tage in jedem Jahr
     0@e-10 Ostersonntag-10 Tage in jedem Jahr
     00000000@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 ISO-Woche in jedem Jahr
     0@a   Der Freitag der 10'ten ISO-Woche in jedem Jahr
     0@a1  Der Samstag der 10'ten ISO-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 ISO-Woche in jedem Jahr
     ;
     ; Der folgende Eintrag wird von ALLEN
     ;   Terminwarnungszeitraum-Modifizierern verarbeitet.
     ;
     1994*d1sun#SON.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

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

     $a=Freitag der 13'te%s0000
     $b= %e0000
     $c=fr2
     $d=fr3
     00000113 $a01$c$b01$c
     00000113 $a01$d$b0$1d
     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:

     $ gcal -H no -u -x -f ./demo3.rc 1996+2002
     -|
     -| Fr,  13 Sep 1996: Freitag der 13'te
     -| Fr,  13 Dez 1996: Freitag der 13'te
     -|
     -| Fr,  13 Jun 1997: Freitag der 13'te
     -|
     -| Fr,  13 Feb 1998: Freitag der 13'te
     -| Fr,  13 Mae 1998: Freitag der 13'te
     -| Fr,  13 Nov 1998: Freitag der 13'te
     -|
     -| Fr,  13 Aug 1999: Freitag der 13'te
     -|
     -| Fr,  13 Okt 2000: Freitag der 13'te
     -|
     -| Fr,  13 Apr 2001: Freitag der 13'te
     -| Fr,  13 Jul 2001: Freitag der 13'te
     -|
     -| Fr,  13 Sep 2002: Freitag der 13'te
     -| Fr,  13 Dez 2002: Freitag der 13'te

Oder eine etwas kürzere Version der Ressourcendatei `demo3.rc' mit dem
Dateinamen `demo4.rc', mit der ebenfalls alle Freitage bestimmt werden
können, die auf den 13'ten Tag eines Monats fallen:

     $a=Freitag der 13'te ist am %n+12%s0000
     $b= %e0000
     $c=so1
     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:

     $ gcal -H no -u -x -f ./demo4.rc 1996+2002
     -|
     -| So,   1 Sep 1996: Freitag der 13'te ist am 13-Sep-1996
     -| So,   1 Dez 1996: Freitag der 13'te ist am 13-Dez-1996
     -|
     -| So,   1 Jun 1997: Freitag der 13'te ist am 13-Jun-1997
     -|
     -| So,   1 Feb 1998: Freitag der 13'te ist am 13-Feb-1998
     -| So,   1 Mae 1998: Freitag der 13'te ist am 13-Mae-1998
     -| So,   1 Nov 1998: Freitag der 13'te ist am 13-Nov-1998
     -|
     -| So,   1 Aug 1999: Freitag der 13'te ist am 13-Aug-1999
     -|
     -| So,   1 Okt 2000: Freitag der 13'te ist am 13-Okt-2000
     -|
     -| So,   1 Apr 2001: Freitag der 13'te ist am 13-Apr-2001
     -| So,   1 Jul 2001: Freitag der 13'te ist am 13-Jul-2001
     -|
     -| So,   1 Sep 2002: Freitag der 13'te ist am 13-Sep-2002
     -| So,   1 Dez 2002: Freitag der 13'te ist am 13-Dez-2002

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

     $a=Werktag
     $c=%e0000$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
`demo5.rc':

     $a=Werktag
     $c=%e0000$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 Ressourcendateien gedacht ist:

     #include "$f"

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

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

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

     ;
     ; `swtime.rc'; Sommerzeit/Winterzeit BRD
     ;
     $a=zeitumstellung am Sonntag
     ;
     a=03so9
     0@a-2#+2 Sommer$a~+1 Std. (02.00 --> 03.00 Uhr)%s1980
     ;
     a=09so9
     0@a-2#+2 Winter$a~-1 Std. (03.00 --> 02.00 Uhr)%s1980 %e1995
     ;
     a=10so9
     0@a-2#+2 Winter$a~-1 Std. (03.00 --> 02.00 Uhr)%s1996

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

Der heutzutage benutzte Kalender wurde 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 korrigierte Kaiser Augustus im Jahre 8 vor Christus die Fehler.
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 benannte kurzerhand einen anderen Monat nach
sich selbst, 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.

Dieser Kalender ist als der "Julianische Kalender" in die
Geschichtsschreibung eingegangen und hat ein reines Sonnenjahr zur
Grundlage.  Die Soll-Länge eines Sonnenjahres (bzw. sogenannten
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) 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
3323 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.  Russland war das letzte europäische
Land was das tat, und zwar nach der Kommunistischen Revolution, welche
am 25'ten Oktober 1917 (Gregorianisch) stattfand.  Daraus resultierte,
daß die UDSSR den Tag der Oktoberrevolution nach dem alten Julianischen
Kalender am 7'ten November feierte.

Als bisher letzter Staat stellte die Volksrepublik China im Jahre 1949
seine Zeitrechnung auf den Gregorianischen Kalender um.  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, als auch der Kirchen.

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

Zwei kleine Hilfsprogramme sind im Gcal 2.10 Paket enthalten.  Das
`tcal' Programm startet das Gcal Programm mit dem Datum des morgigen
Tages.  Und das `txt2gcal' Programm erzeugt eine wortgetreue Gcal
Ressourcendatei aus einer Textdatei.

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

`tcal' ist ein Programm, welches `gcal' mit dem Datum des morgigen
Tages aufruft (entspricht der `--shift=1' Option).  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 an Tagen ist, die das gewünschte Datum vom
aktuellen Datum entfernt ist.  Die `--shift' Option muß vor allen
anderen ARGUMENTEN, die an das Gcal Programm übergeben werden,
angegeben sein.

Falls eine `GCALPROG' Umgebungsvariable *siehe GCALPROG:
Umgebungsvariablen.) definiert und mit dem Dateinamen des ausführbaren
Gcal Programms gesetzt ist, so benutzt `tcal' diesen Dateinamen um Gcal
aufzurufen.  Anderenfalls benutzt `tcal' den beim Kompiliervorgang
eingebrannten Dateinamen `gcal' um das Gcal Progamm aufzurufen.  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 erfolgreiches Programmende.

`--version'
     Ausgabe der Versionsnummer, sodann erfolgreiches Programmende.

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

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 `-' als Argument angegeben, so liest und
verarbeitet das Programm alle Eingaben, die vom Standardeingabekanal
kommen.  Wird kein DATUMTEIL als Argument angegeben, so wird von
`txt2gcal' eine `0' für den Datumteil erzeugt.  Alle Ergebnisse werden
stets auf dem Standardausgabekanal 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 erfolgreiches Programmende.

`--version'
     Ausgabe der Versionsnummer, sodann erfolgreiches Programmende.

Nun zu einem Beispiel, welches den Einsatz von `txt2gcal' näher
erläutern soll.  Angenommen es existiert eine Textdatei mit dem Namen
`demo' und dem folgenden Inhalt:

             Hallo Freunde,
     
     Ich bin der Demo-Text, der lustige Zeichen und Zeichensequenzen
     enhaelt 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
`demo.rc' umgelenkt wird:

     $ txt2gcal demo 0*d1#999 > demo.rc
     => 0*d1#999 \        Hallo Freunde,~\
     => ~\
     => Ich bin der Demo-Text, der lustige Zeichen und Zeichensequenzen~\
     => enhaelt 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 `demo.rc' aus der
Textdatei `demo' erzeugt.  Abschließend erfolgt die Betrachtung, wie
Gcal diese neue Ressourcendatei interpretiert:

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

Gesichtspunkte zur Internationalisierung
****************************************

Gcal besitzt ab Version 2.00 die Fähigkeit, Meldungstexte nicht mehr
nur allein in englischer Landessprache auszugeben, sondern auch in
beliebigen anderen Landessprachen, da Bestandteile des GNU `gettext'
Pakets in die Software integriert worden sind.  *Siehe Introduction:
(gettext)Top, für weitere Details.

Gcal ist intern so eingestellt, daß es die englische Landessprache zur
Ausgabe aller Meldungstexte verwendet, sofern keine andere Landessprache
verwendet werden soll.  Werden Meldungstexte in einer anderen
Landessprache gewünscht, so werden diese von Gcal aus einem
sogenannten *message catalog* zur Laufzeit eingelesen.  Die folgenden
Landessprachen werden von Gcal 2.10 unterstützt:

     Englisch (en)
     Deutsch (de)

Um eine andere Landessprache anstelle der englischen Landessprache
vorzuwählen, braucht nur in einer der Umgebungsvariablen (die hier in
absteigender Priorität aufgelistet sind)

  1. `LANGUAGE' (*siehe LANGUAGE: Umgebungsvariablen.)

  2. `LC_ALL' (*siehe LC_ALL: Umgebungsvariablen.)

  3. `LC_MESSAGES' (*siehe LC_MESSAGES: Umgebungsvariablen.)

  4. `LANG' (*siehe LANG: Umgebungsvariablen.)

ein entsprechender Sprachkode eintragen zu werden.

Endanwender benutzen normalerweise nur die `LANG' Umgebungsvariable um
Gcal mitzuteilen, welche Landessprache zur Laufzeit verwendet werden
soll.  Angenommen Benutzer möchten Gcal mit Meldungstexten in
deutscher Landessprache betreiben, so können diese die shell dazu
veranlassen, die Umgebungsvariable `LANG' mit dem Inhalt `de' zu
besetzen, und zwar durch `setenv LANG de' (bei Benutzung der `csh'
shell) oder durch `export LANG; LANG=de' (bei Benutzung des `sh' shell).
Selbstverständlich kann dieser Befehl auch in der `.login' bzw.
`.profile' Datei von Endanwendern enthalten sein.  *Siehe The User's
View: (gettext)Users, für weitere Details.

Wie zuvor dargestellt reicht bereits der simple Eintrag von `de' in der
Umgebungsvariablen `LANG' aus, um die Ausgabe deutscher Meldungstexte zu
veranlassen.  `de' ist der aus zwei Buchstaben bestehende Sprachkode
für Deutsch, der in der ISO-639:1988 definiert ist und im weiteren
Verlauf als "einfache Sprachkode-Information" bezeichnet wird.  Andere
Sprachkodes können dieser ISO-Norm entnommen werden (z.B. `fr' für
Französisch, `es' für Spanisch etc.).

Da Gcal als Kalenderprogramm auch den Eigenheiten der verwendeten
Landessprache hinsichtlich der Anordnung von Tag, Monat und Jahr (und
weiterem) in einem dargestellten Datum, dem Zeitraum der
Gregorianischen Reform und der Darstellungsweise von Kalenderblättern,
nachkommen muß, sind diese Kriterien ebenfalls an den Sprachkode
gebunden (genaugenommen an eine erweiterte Sprachkode-Information).

So bewirkt ein `en' Sprachkode folgende interne Grundeinstellungen
vorgenannter Kriterien:

   * US amerikanisches Datumformat

   * Gregorianische Reformation war 1752

   * Starttag der Woche ist Sonntag

   * Kalenderblattdarstellung

             September 1994
          Mo Di Mi Do Fr Sa So
                    1  2  3  4
           5  6  7  8  9 10 11
          12 13 14 15 16 17 18
          19 20 21 22 23 24 25
          26 27 28 29 30

Und ein `de' Sprachkode (oder andere Sprachkodes, für welche in Zukunft
ein *message catalog* erstellt und mit ausgeliefert wird) bewirkt
folgende interne Grundeinstellungen:

   * Deutsches Datumformat

   * Gregorianische Reformation war 1582

   * Starttag der Woche ist Montag

   * Kalenderblattdarstellung

          September 1994
          
          Montag           5 12 19 26
          Dienstag         6 13 20 27
          Mittwoch         7 14 21 28
          Donnerstag    1  8 15 22 29
          Freitag       2  9 16 23 30
          Samstag       3 10 17 24
          Sonntag       4 11 18 25

Alle diese internen Grundeinstellungen sind durch die Angabe der
entsprechenden Optionen (`--date-format', `--gregorian-reform',
`--starting-day' und `--type') veränderbar.

Falls kein Sprachkode vorgefunden wird, so nimmt Gcal die interne
Grundeinstellung des `en' Sprachkodes an (besser gesagt der erweiterten
Sprachkode-Information `en_us') an.

Falls ein Sprachkode angegeben ist, für den kein *message catalog*
installiert wurde, so nimmt Gcal die internen Grundeinstellungen des
`de' Sprachkodes an, gibt aber die Meldungstexte in der Englischen
Landessprache aus.  Dieses Verhalten erscheint mir im Augenblick als
die zweckmäßigste Lösung in einem solchen Fall.  Da die Englische
Landessprache weltweit stärker verbreitet ist als die Deutsche oder
andere Landessprachen, macht es in einem solchen Fall durchaus Sinn,
die Meldungstexte in der Englischen Landessprache auszugeben.
Allerdings sind die sonstigen Kriterien, die an die Englische
Landessprache gebunden sind, so speziell für Benutzer anderer
Landessprachen, daß es durchaus Sinn macht, diese Kriterien an die
internen Grundeinstellungen des `de' Sprachkodes anzulehnen, da in den
meisten europäischen Ländern (die ich hier zum Maßstab mache) die
internen Grundeinstellungen des `de' Sprachkodes verwendet werden.

Nun werden sich britische Endanwender sicherlich fragen, ob auch ihr
Datumformat als interne Grundeinstellung benutzt werden kann (alle
anderen internen Grundeinstellungen der einfachen `en'
Sprachkode-Information entsprechen ja sonst ihren Kriterien).  Die
Antwort lautet schlich und ergreifend `ja', allerdings muß dieser
Benutzerkreis anstelle einer einfachen Sprachkode-Information eine
"erweiterte Sprachkode-Information" in der Umgebungsvariable `LANG'
angeben.  Die übliche Schablone einer erweiterten
Sprachkode-Information ist wie folgt aufgebaut:

   * Nach XPG Syntax (X/Open Portability Guide):

          LANDESSPRACHE[_TERRITORIUM][.ZEICHENSATZ][@MODIFIZIERER]

   * Nach CEN Syntax (Comite Europen de Normalisation):

          LANDESSPRACHE[_TERRITORIUM][+PUBLIKUM][+SPEZIAL][,SPONSOR][_ÜBERARBEITUNG]

Beide Syntaxen enhalten die Bestandteile LANDESSPRACHE und TERRITORIUM,
welche von Gcal zur Auswahl der Landessprache und der sonstigen
Kriterien verwendet werden.  Der Bestandteil LANDESSPRACHE entspricht
der einfachen Sprachkode-Information, und der Bestandteil TERRITORIUM
ist ein aus zwei Buchstaben bestehender Territoriumskode, wie er in der
ISO-3166 definiert ist, z.B. `gb' für Großbritannien oder `us' für
die USA.  Für weitere Einzelheiten hierzu sei auf die einschlägige
Fachliteratur verwiesen.  Brititsche Endanwender brauchen nur die shell
dazu veranlassen, die Umgebungsvariable `LANG' mit dem Inhalt `en_gb'
zu besetzen, sodann können diese das britische Datumformat als interne
Grundeinstellung benutzen.

Metasymbole
***********

Folgende *metasprachliche* Konventionen werden bei der Darstellung von
Optionen, Argumenten, Kommandos und Schablonen innerhalb dieses
Dokumentes verwendet:

`N'
     Nichtoptionales Argument, N muß eine zulässige Zahl sein.

`e|DVAR'
     Nichtoptionales Argument, welches ein einzelnes alphabetisches
     Zeichen sein muß.

`[TEXT]'
     Optionales Argument, TEXT ist eine zulässige
     Zeichenkettenkonstante.

`[AB]'
     Optionale Argumente, deren Anzahl und Anordung beliebig ist, z.B.:

          NICHTS, A, B, AB, BA ...

`{AB}'
     Nichtoptionale Argumente, deren Anordnung beliebig ist und von
     denen mindestens eins bis hin zu einer beliebigen Anzahl angegeben
     werden kann, z.B.:

          A, B, AB, BA ...

`[A|B]'
     Optionale Argumente, entweder A oder B, aber nicht beide.

`A|B'
     Nichtoptionale Argumente, entweder A oder B, aber nicht beide.

`[A[B]]'
     Optionale Argumentliste, entweder A oder AB, aber nicht B.

`[A|B[C]]'
     Optionale Argumentliste, entweder A oder B oder AB oder AC, aber
     nicht C.

`[A|BC]'
     Optionale Argumentliste, entweder AC oder BC, aber nicht A oder B
     oder C.

`[A]|[B]'
     Optionale Argumentlisten, entweder Liste A oder Liste B, aber
     nicht beide.

`[...]'
     Zusätzliche Argumente/Dateien dürfen angegeben werden und sind
     optional.

Kodierschema
************

Es folgt nun die tabellarische Aufstellung des Kodierschemas, welches
für den *Datumteil* (JJJJ...) einer Zeile der Ressourcendatei
verwendet werden kann, und der Modifizierer, welche die Kurzoption
`-c|C[]' annehmen darf, bzw. die Argumente, welche die Langoption
`--period-of-fixed-dates=ARGUMENT' annehmen darf.  Aus diesen Tabellen
kann ersehen werden, welche *Terminwarnungsargumente* mit welchem
*Datumteil* einer Zeile der Ressourcendatei korrespondieren, d.h. bei
Anwahl eines *Terminwarnungsarguments* berücksichtigt werden; da Gcal
eben nicht alle vorhandenen Einträge in einer Ressourcendatei
berücksichtigt, sondern nur solche, die in einem bestimmten Verhältnis
zum *Terminwarnungsargument* stehen, und somit die Ausgabe
überflüssiger Informationen verhindert wird.

Im *Datumteil* `JJJJ...':

JJJJ
     steht für jede Jahreszahl (0001...9999).

MM
     steht für jede Monatszahl (01...12 oder 99) bzw. jeden textlichen
     Monatsnamen im 3-stelligen Kurzformat (Jan, Feb...).

TT
     steht für jede Tageszahl (1...28, 29, 30, 31 oder 99).

WWW
     steht für jeden textlichen Wochentagsnamen im 2...3-stelligen
     Kurzformat (Mon...Son).

?
     steht für jeden Einzelbuchstaben des Alphabets (Groß- bzw.
     Kleinbuchstaben werden nicht unterschieden).

N
     steht für jede positive Ganzzahl (eine oder mehrere Ziffern).

Kodierschema Tabelle 1
======================

In dieser Tabelle werden alle möglichen Kodierungen von einem Datum im
*Datumteil* einer Ressourcendatei mit allen dazu möglichen Kodierungen
der Modifizierer der Kurzoption `-c|C[]' gegenübergestellt.

     *Bitte beachten:*
     Die `-c', `-ct', `-cNd', `-c*d|wN[WWW]', `-c@e|DVAR[[+|-]N[WWW]]',
     `-cMMTT' und `-cMMWWWN' Optionen berücksichtigen *alle*
     Kodiervariationen des *Datumteils*!

`*Datumteil einer Ressourcendatei*'
     *Kurzoption -c|C[]*

`00000000'
     `-cN+|-'

`000000TT'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]'

`0000MM00'
     `-cN+|-'

`0000MMTT'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`JJJJ0000'
     `-cN+|-'

`JJJJ00TT'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]'

`JJJJMM00'
     `-cN+|-'

`JJJJMMTT'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`000000WWW'
     `-cNw|+|-', `-cw[+|-]'

`0000MMWWW'
     `-cNw|+|-', `-cw[+|-]'

`JJJJ00WWW'
     `-cNw|+|-', `-cw[+|-]'

`JJJJMMWWW'
     `-cNw|+|-', `-cw[+|-]'

`000000WWWN'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]'

`0000MMWWWN'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`JJJJ00WWWN'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]'

`JJJJMMWWWN'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`0000*dN[WWW]'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`JJJJ*dN[WWW]'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`0000*wN[WWW]'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`JJJJ*wN[WWW]'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`0000@?[+|-]N[WWW]'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

`JJJJ@?[+|-]N[WWW]'
     `-cNw|+|-', `-cw[+|-]', `-cm[+|-]', `-cy[+|-]', `-clNd|w|+|-',
     `-cl*d|wN[WWW]',
     `-cl@e|DVAR[[+|-]N[WWW]]', `-clMMTT', `-clMMWWWN'

Kodierschema Tabelle 2
======================

In dieser Tabelle werden alle möglichen Kodierungen der Modifizierer
der Kurzoption `-c|C[]' mit allen dazu möglichen Kodierungen von einem
Datum im *Datumteil* einer Ressourcendatei gegenübergestellt.

`*Kurzoption -c|C[]*'
     `*Datumteil einer Ressourcendatei*'

`-c'
`-ct'
`-cNd|+|-'
`-cMMTT'
`-cMMWWWN'
`-c*d|wN[WWW]'
`-c@e|DVAR[[+|-]N[WWW]]'
     `00000000', `0000MM00', `JJJJ0000', `JJJJMM00', `000000TT',
     `0000MMTT', `JJJJ00TT', `JJJJMMTT', `000000WWW', `0000MMWWW',
     `JJJJ00WWW', `JJJJMMWWW', `000000WWWN', `0000MMWWWN', `JJJJ00WWWN',
     `JJJJMMWWWN', `0000*dN', `0000*dNWWW', `JJJJ*dN', `JJJJ*dNWWW',
     `0000*wN', `0000*wNWWW', `JJJJ*wN', `JJJJ*wNWWW', `0000@?[+|-]N',
     `0000@?[+|-]NWWW', `JJJJ@?[+|-]N', `JJJJ@?[+|-]NWWW'

`-cw[+|-]'
`-cNw'
     `000000TT', `0000MMTT', `JJJJ00TT', `JJJJMMTT', `000000WWW',
     `0000MMWWW', `JJJJ00WWW', `JJJJMMWWW', `000000WWWN', `0000MMWWWN',
     `JJJJ00WWWN', `JJJJMMWWWN', `0000*dN', `0000*dNWWW', `JJJJ*dN',
     `JJJJ*dNWWW', `0000*wN', `0000*wNWWW', `JJJJ*wN', `JJJJ*wNWWW',
     `0000@?[+|-]N', `0000@?[+|-]NWWW', `JJJJ@?[+|-]N',
     `JJJJ@?[+|-]NWWW'

`-cm[+|-]'
     `000000TT', `0000MMTT', `JJJJ00TT', `JJJJMMTT', `000000WWWN',
     `0000MMWWWN', `JJJJ00WWWN', `JJJJMMWWWN', `0000*dN', `0000*dNWWW',
     `JJJJ*dN', `JJJJ*dNWWW', `0000*wN', `0000*wNWWW', `JJJJ*wN',
     `JJJJ*wNWWW', `0000@?[+|-]N', `0000@?[+|-]NWWW', `JJJJ@?[+|-]N',
     `JJJJ@?[+|-]NWWW'

`-cy[+|-]'
`-clNd|w|+|-'
`-clMMTT'
`-clMMWWWN'
`-cl*d|wN[WWW]'
`-cl@e|DVAR[[+|-]N[WWW]]'
     `0000MMTT', `JJJJMMTT', `0000MMWWWN', `JJJJMMWWWN', `0000*dN',
     `0000*dNWWW', `JJJJ*dN', `JJJJ*dNWWW', `0000*wN', `0000*wNWWW',
     `JJJJ*wN', `JJJJ*wNWWW', `0000@?[+|-]N', `0000@?[+|-]NWWW',
     `JJJJ@?[+|-]N', `JJJJ@?[+|-]NWWW'

Umgebungsvariablen
******************

Hier ist eine Liste aller Umgebungsvariablen, die von Gcal benutzt
werden:

`COLUMNS'
`CO'
     Setzt die Anzahl der Spalten des Bildschirms.  Hat Vorrang vor der
     Anzahl der Spalten, welche die `TERM' Umgebungsvariable oder das
     System selbst definiert.

`GCAL'
     Argumente welche an Gcal automatisch übergeben werden.

`GCALANSI'
     Wenn definiert oder gesetzt, so werden ANSI
     Escape-Hervorhebungssequenzen als Grundeinstellung benutzt bzw.
     substituiert, falls keine anderen Hervorhebungssequenzen mittels
     Kommandozeilenoption definiert werden oder in der Termcap
     Bibliotheksdatei aufgefunden werden.

`GCAL_DATE_FORMAT'
     Enthält den Datumformattext, der die Anordnung von einem
     auszugebenden Datum bestimmt.  Hat Vorrang vor dem
     Grundeinstellungs-Datumformattext.

`GCALPATH'
     Durch (`:') Doppelpunkt separierte Liste von Dateiverzeichnissen,
     welche durchsucht werden, um die `.gcalrc' Datei zu finden.  Hat
     Vorrang vor `GCAL_USR_DATADIR' und `GCAL_SYS_DATADIR'.

`GCALPROG'
     Enthält den Dateinamen des ausführbaren Gcal Programms, welcher
     vom Programm `tcal' benutzt wird, um Gcal aufzurufen.  Hat Vorrang
     vor dem beim Kompilationsvorgang in `tcal' eingebrannten Dateinamen
     `gcal'.

`GCAL_USR_DATADIR'
     Name eines Dateiverzeichnisses relativ zum `HOME'
     Dateiverzeichnis, in welchem der Benutzer seine persönlichen bzw.
     *privaten* Ressourcendateien (Termindateien) speichert.  Hat
     Vorrang vor `GCAL_SYS_DATADIR'.

`GCAL_SYS_DATADIR'
     Name eines Dateiverzeichnisses absolut zum *Wurzel*/*$(prefix)*
     Dateiverzeichnis, in welchem der Systemadministrator allgemeine
     bzw.  *öffentliche* Ressourcendateien (Termindateien) speichert.

`HOME'
     Name des Heimatverzeichnisses des Benutzers (wird benutzt um die
     `.gcalrc' Datei zu finden).  Hat Vorrang vor `GCALPATH',
     `GCAL_USR_DATADIR' und `GCAL_SYS_DATADIR'.

`LANGUAGE'
     Die Landessprache und sonstige kulturspezifische Konventionen, die
     Gcal zur Laufzeit verwenden soll.  Hat Vorrang vor `LC_ALL',
     `LC_MESSAGES' und `LANG'.

`LC_ALL'
     Die Landessprache und sonstige kulturspezifische Konventionen, die
     Gcal zur Laufzeit verwenden soll.  Hat Vorrang vor `LC_MESSAGES'
     und `LANG'.

`LC_MESSAGES'
     Die Landessprache und sonstige kulturspezifische Konventionen, die
     Gcal zur Laufzeit verwenden soll.  Hat Vorrang vor `LANG'.

`LANG'
     Die Landessprache und sonstige kulturspezifische Konventionen, die
     Gcal zur Laufzeit verwenden soll.

`LINES'
`LI'
     Setzt die Anzahl der Zeilen des Bildschirms.  Hat Vorrang vor der
     Anzahl der Zeilen, welche die `TERM' Umgebungsvariable oder das
     System selbst definiert.

`PAGER'
     Der Names des externen Paginiererprogramms, das verwendet wird,
     wenn Paginierung (`-p' bzw. `--pager' Option) gewünscht wird.

`PATH'
     Durch (`:') Doppelpunkt separierte Liste von Dateiverzeichnissen,
     welche durchsucht werden, um das "externe" Paginiererprogramm zu
     finden.  *Siehe `--pager': Globale Optionen, für weitere Details.

`TERM'
     Der Terminaltyp, auf dem Gcal zum Ablauf kommt.

`TZ'
     Die Zeitzoneninformation, mit dem der Datumtext in versendeten
     Emails, erzeugten Anwortdateien und erzeugten shell script Dateien
     versehen wird.

Fehlerkodes
***********

Gcal erzeugt folgende *exit* Kodes:

`127'
     Hilfeseite, Softwarelizenz bzw. Versionsnummer angefordert
     (einstellbar).

`126'
     Unzulässige Option bei Programmaufruf.

`125'
     Jahr außerhalb zulässigen Bereichs bei Ermittlung des
     Ostersonntags.

`124'
     Virtueller Speicher erschöpft.

`123'
     Unzulässiger Datumeintrag in Ressourcen- bzw. Includedatei.

`122'
     Ungültiger Monatseintrag in Ressourcen- bzw. Includedatei.

`121'
     Ungültiger Tageseintrag in Ressourcen- bzw. Includedatei.

`120'
     Mißgebildete *#include* Anweisung in Ressourcen- bzw.
     Includedatei.

`119'
     Unzulässige rekursive/zyklische *#include* Anweisung in
     Ressourcen- bzw.  Includedatei.

`118'
     Ressourcen- bzw. Includedatei nicht gefunden.

`117'
     Ungültiges N'ter Wochentagsfeld (nur 1...5 oder 9 erlaubt).

`116'
     Fehlendes *whitespace* Trennzeichen zwischen *Datumteil* und
     *Textteil*.

`115'
     Antwortdatei bzw. shell script kann nicht geschrieben werden.

`114'
     Illegale Datumvariablen-Operation.

`113'
     Datumvariable undefiniert.

`112'
     Zuweisung von ungültigem Datumwert an Datumvariable.

`111'
     Versenden der Ausgabe an Email Adresse hat versagt.

`110'
     Interner Fehler, C Funktion pipe(), fork(), execlp() oder unlink()
     hat versagt.

`109'
     Fehler beim Lesen der Ressourcen-, Include- bzw. Antwortdatei
     aufgetreten.

`108'
     Illegales Zeichen in Antwortdatei vorgefunden.

`107'
     Interner Fehler, ungültiger Wert für die Größe einer internen
     Tabelle aufgetreten.

`106'
     Ungültiger Datumformattext angegeben.

`105'
     Illegale Textvariablen-Definition.

`1'
     Keine Ausgabe von Terminwarnungen obwohl Option `-c|C[]' oder
     `-f|F DATEINAME[+...]' aktiviert.

`0'
     Fehlerfreier Programmlauf.

Index von Kommandozeilenargumenten
**********************************

Das ist eine alphabetische Liste der Kommandozeilenargumente, die von
Gcal verarbeitet werden.

(entfernt)


Index von Umgebungsvariablen
****************************

Das ist eine alphabetische Liste der Umgebungsvariablen, die von Gcal
berücksichtigt werden.

(entfernt)


Stichwortverzeichnis
********************

(entfernt)


