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

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

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

Copyright (c) 1994-1997, 2000 Thomas Esken

Diese Ausgabe ist für Gcal Version 3.00.

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

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

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

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

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


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

Aufruf von `gcal2txt'
=====================

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

     gcal2txt [--help | --version] | [RESSOURCENDATEI | -]

Wird keine RESSOURCENDATEI oder aber ein einzelnes `-' Zeichen als
Argument angegeben, so liest und verarbeitet das Programm alle Eingaben,
die vom _Standardeingabe-Gerätekanal_ kommen.  Alle Ergebnisse werden
stets auf dem _Standardausgabe-Gerätekanal_ ausgegeben.  Ein
Programmendestatus 0 bedeutet, daß die Verarbeitung erfolgreich war,
ein anderer Endestatus verweist auf einen Fehler während der
Verarbeitung.

Sinn und Zweck von Gcal2txt ist, all das, was vom Txt2gcal Programm in
die Ausgabe eingebracht wurde, wieder rückgängig zu machen!

Das Programm akzeptiert die folgenden Optionen:

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

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

Und nun ebenfalls zu einem Beispiel, welches den Einsatz von Gcal2txt
näher erläutern soll.  Dazu wird die Ressourcendatei mit dem Namen
`tdemo-1.rc' benutzt, welche im vorherigen Abschnitt mittels des
Txt2gcal Programms aus einer Textdatei erzeugt wurde (*note Aufruf von
`txt2gcal': Aufruf von txt2gcal.), und die ja wie folgt aussieht:

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

Nun zur Betrachtung, wie diese Ressourcendatei von Gcal2txt verarbeitet
wird:

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


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

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.  *Note 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 so
genannten _message catalog_ zur Laufzeit eingelesen.  Die folgenden
Landessprachen werden von Gcal 3.00 unterstützt:

*Landessprache*          *Sprachkode*

Englisch                 `en'
Deutsch                  `de'
Französisch              `fr'
Niederländisch           `nl'
Polnisch                 `pl'
Russisch                 `ru'
Schwedisch               `sv'

Um eine andere Landessprache anstelle der englischen Landessprache
vorzuwählen, so braucht nur in einer der Umgebungsvariablen(1) (*note
Internationalisierung-Footnote-1::):

1.  `LANGUAGE'
2.  `LC_ALL'
3.  `LC_MESSAGES'
4.  `LANG'

ein entsprechender Sprachkode eingetragen 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 der `sh' shell).
Selbstverständlich kann dieser Befehl auch in der `.login' bzw.
`.profile' Datei beim Endanwender enthalten sein.  *Note 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(2) (*note
Internationalisierung-Footnote-2::).

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, der Art der Wochennummern und der Darstellungsweise von
Kalenderblättern, nachkommen muß, sind diese Kriterien ebenfalls an den
Sprachkode gebunden(3) (*note Internationalisierung-Footnote-3::).

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

   * US amerikanisches Datumformat

   * Gregorianische Reformation war 1752

   * Starttag der Woche ist Sonntag

   * Standard-Wochennummern

   * Kalenderblattdarstellung

             September 1994
          So Mo Di Mi Do Fr Sa
                       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(4) (*note Internationalisierung-Footnote-4::)
bewirkt folgende interne Grundeinstellungen:

   * Deutsches Datumformat

   * Gregorianische Reformation war 1582

   * Starttag der Woche ist Montag

   * ISO-8601:1988 Wochennummern

   * 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
Optionen `--date-format', `--gregorian-reform', `--starting-day',
`--iso-week-number' und `--type' veränderbar.

Falls kein Sprachkode vorgefunden wird, so nimmt Gcal die interne
Grundeinstellung des `en' Sprachkodes an(5) (*note
Internationalisierung-Footnote-5::).

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 aber 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) im
wesentlichen 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(6) (*note
Internationalisierung-Footnote-6::).  Die Antwort lautet schlicht 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 (Comité Europén de Normalisation):

          LANDESSPRACHE[_TERRITORIUM][+PUBLIKUM][+SPEZIAL][,SPONSOR][_ÜBERARBEITUNG]

Beide Syntaxen enthalten 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.  Britische 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.


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

(1) Hier in absteigender Priorität ihrer Berücksichtigung aufgestellt.

(2) Wie zum Beispiel `fr' für Französisch, `es' für Spanisch....

(3) Genaugenommen an eine erweiterte Sprachkode-Information.

(4) Oder andere Sprachkodes, für welche in Zukunft ein _message
catalog_ erstellt und mit ausgeliefert wird.

(5) Besser gesagt der erweiterten Sprachkode-Information `en_US'.

(6) Alle anderen internen Grundeinstellungen der einfachen `en'
Sprachkode-Information entsprechen ja sonst bereits ihren Kriterien.


File: gcal.info,  Node: Metasymbole,  Next: Regulaere Ausdruecke,  Prev: Internationalisierung,  Up: Top

Metasymbole
***********

Folgende _metasprachliche_ Konventionen werden bei der Darstellung von
Optionen, Kommandos, Argumenten und Schablonen innerhalb dieses
Dokuments verwendet:

`N'
     Nichtoptionales Argument, N muß eine zulässige Zahl sein.

`e|t|DVAR'
     Nichtoptionales Argument, welches ein einzelnes alphabetisches
     Zeichen sein muß.

`$TVAR'
     Nichtoptionales Argument, welches ein einzelnes alphabetisches
     Zeichen sein muß, das von einem `$' Zeichen angeführt wird.

`[TEXT]'
     Optionales Argument, TEXT ist eine zulässige
     Zeichenkettenkonstante.

`[AB]'
     Optionale Argumente, deren Anzahl und Anordnung 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 AC oder BC, 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 dürfen angegeben werden und sind optional.


File: gcal.info,  Node: Regulaere Ausdruecke,  Next: Regexp (kurz),  Prev: Metasymbole,  Up: Top

Reguläre Ausdrücke
******************

* Menu:

* Benutzung von Regexp::  Wie reguläre Ausdrücke benutzt werden können.
* Regexp Operatoren::     Was sind regulär-Ausdruck Operatoren?

Dieser Anhang ist aus den `gawk-3.0.0' und `regex-0.12' Handbüchern
abgeleitet.

Ein "regulärer Ausdruck", oder "regexp", ist ein Weg zur Beschreibung
einer Klasse von Zeichenketten, oder "strings".  Der einfachste
reguläre Ausdruck ist eine Folge von Buchstaben, Zahlen, oder beidem.
Solch ein regexp paßt auf jedwede Zeichenkette, die eine solche Folge
enthält.  Deswegen stimmt der regexp `foo' mit jeder Zeichenkette
überein, die `foo' enthält.  Andere Arten von regulären Ausdrücken
erlauben eine weitaus kompliziertere Angabe von string-Klassen.

Gcal benutzt genau eine der folgenden regulär-Ausdruck
Programmbibliotheken bzw. Methoden, welche zur Konfigurationszeit, oder
genaugenommen, Kompilationszeit der Software ausgewählt wird; und die
hier in absteigender Priorität hinsichtlich ihrer Auswahl angegeben
sind:

*Nr.**Funktion*                                             *Symbol*

1.   GNU `re_compile_pattern()' und `regex.h'               `GNU-REGEX'
2.   POSIX `regcomp()' und `regex.h'                        `POSIX-REGEX'
3.   BSD `re_comp()'                                        `BSD-REGEX'
4.   System V `regcmp()'                                    `SysV-REGEX'
5.   Henry Spencer V8 `regcomp()' und `regexp.h'            `V8-REGEX'
6.   Mustererkennung wird unterstützt, aber ohne            `NO-REGEX'
     Metazeichen                                            

Benutzen Sie `gcal --version' um festzustellen, welche Art von
regulär-Ausdruck Programmbibliothek bzw. Methode in Ihr Gcal Programm
eingebrannt ist!


File: gcal.info,  Node: Benutzung von Regexp,  Next: Regexp Operatoren,  Prev: Regulaere Ausdruecke,  Up: Regulaere Ausdruecke

Benutzung von regulären Ausdrücken
==================================

Ein regulärer Ausdruck kann als Suchmuster benutzt werden, wenn bei
Aufruf von Gcal die `--filter-text=SUCHMUSTER' Option angegeben wird.

*Note Termin Option `--filter-text=SUCHMUSTER': x-filter-text, für
weitere Details.

Der reguläre Ausdruck wird mit dem gesamten, vollständig expandierten
Text jedes *gültigen* Termins verglichen, und der Termin wird nur dann
ausgegeben, falls das Suchmuster mit dem Text(1) (*note Benutzung von
Regexp-Footnote-1::) übereinstimmt.


File: gcal.info,  Node: Benutzung von Regexp-Footnotes,  Up: Benutzung von Regexp

(1) Für einen erfolgreichen Vergleich wird normalerweise nur eine
Übereinstimmung mit einem Teil des Textes benötigt.


File: gcal.info,  Node: Regexp Operatoren,  Prev: Benutzung von Regexp,  Up: Regulaere Ausdruecke

Regulär-Ausdruck Operatoren
===========================

Reguläre Ausdrücke können mit den folgenden Zeichen kombiniert werden,
welche als "regulär-Ausdruck Operatoren" oder "Metazeichen" bezeichnet
werden, um die Leistungsfähigkeit und Vielseitigkeit von regulären
Ausdrücken zu erhöhen.

Hier ist eine Tabelle dieser Metazeichen.  Alle Zeichen, die nicht in
dieser Tabelle aufgeführt sind, stehen für sich selbst.

`\'
     Wird benutzt um die Spezialbedeutung eines Zeichens während des
     Vergleichs zu unterdrücken.  Zum Beispiel:

          \$

     paßt auf das Zeichen `$'.

`^'
     Paßt auf den Anfang einer Zeichenkette.  Zum Beispiel:

          ^@chapter

     paßt auf `@chapter' zu Anfang einer Zeichenkette, und kann dazu
     benutzt werden, um Kapitelanfänge in Texinfo Quellentextdateien zu
     identifizieren.  Das `^' Zeichen wird als ein "Anker" bezeichnet,
     da es das Suchmuster dergestalt verankert, daß es nur zu
     Übereinstimmungen kommen kann, die zu Anfang einer Zeichenkette
     auftreten.

`$'
     Ähnlich wie `^', paßt aber nur auf das Ende einer Zeichenkette.
     Zum Beispiel:

          p$

     paßt auf einen string, der mit `p' endet.  Das `$' Metazeichen ist
     auch ein Anker.

`.'
     Der Punkt paßt auf jedes Einzelzeichen.  Zum Beispiel:

          .P

     führt zu Übereinstimmungen jedes Einzelzeichens, welches von einem
     `P' in einer Zeichenkette gefolgt wird.  Mittels Verkettung kann
     beispielsweise ein regulärer Ausdruck wie `U.A' erzeugt werden,
     welcher auf jede 3-Zeichen Folge paßt, die mit `U' beginnt und mit
     einem `A' endet.

`[...]'
     Wird als "Zeichenliste" bezeichnet.  Diese paßt auf jedes
     _Einzelzeichen_, welches in den eckigen Klammern angegeben wird.
     Zum Beispiel:

          [MVX]

     paßt auf jedes einzelne `M', `V' oder `X' Zeichen in einem string.

     Bereiche von Zeichen werden unter Benutzung eines Bindestrichs
     zwischen den Start- und Endezeichen vereinbart, und das ganze wird
     von eckigen Klammern umschlossen.  Zum Beispiel:

          [0-9]

     paßt auf jede Ziffer.  Mehrfache Bereiche sind erlaubt.  Zum
     Beispiel ist die Liste `[A-Za-z0-9]' ein üblicher Weg, um den
     Gedanken "aller alphanumerischen Zeichen" auszudrücken.

     Um eines der `\', `[', `]', `-' oder `^' Zeichen in eine
     Zeichenliste einzufügen, ist es notwendig, diese mit einem
     anführenden `\' Zeichen auszustatten.  Zum Beispiel:

          [d\]]

     paßt entweder auf `d' oder `]'.

     "Zeichenklassen" sind ein neues Merkmal, die im POSIX Standard
     eingeführt sind.  Eine Zeichenklasse ist eine spezielle
     Bezeichnung, um Zeichenlisten, die mit speziellen Eigenschaften
     ausgestattet sind, zu beschreiben, wohingegen sich aber die
     aktuellen Zeichen selbst von Land zu Land und/oder Zeichensatz zu
     Zeichensatz verändern.  Zum Beispiel unterscheidet sich der
     Begriff, was unter einem alphabetischen Zeichen zu verstehen ist,
     in den USA und in Frankreich.

     Eine Zeichenklasse ist in einem regexp nur _innerhalb_ der Klammern
     einer Zeichenliste gültig.  Zeichenklassen bestehen aus `[:'
     --einem Schlüsselwort, daß die Klasse bezeichnet-- und `:]'.  Es
     folgen nun die Zeichenklassen, welche durch den POSIX Standard
     definiert werden:

    `[:alnum:]'
          Alphanumerische Zeichen.

    `[:alpha:]'
          Alphabetische Zeichen.

    `[:blank:]'
          Leerzeichen und Tabulatorzeichen.

    `[:cntrl:]'
          Steuerzeichen.

    `[:digit:]'
          Numerische Zeichen.

    `[:graph:]'
          Zeichen, die druckbar und zugleich sichtbar sind(1) (*note
          Regexp Operatoren-Footnote-1::).

    `[:lower:]'
          Kleinbuchstaben.

    `[:print:]'
          Druckbare Zeichen(2) (*note Regexp Operatoren-Footnote-2::).

    `[:punct:]'
          Interpunktionszeichen(3) (*note Regexp
          Operatoren-Footnote-3::).

    `[:space:]'
          Leerzeichen(4) (*note Regexp Operatoren-Footnote-4::).

    `[:upper:]'
          Großbuchstaben.

    `[:xdigit:]'
          Hexadezimalziffern.

     Zum Beispiel mußte vor Einführung des POSIX Standards
     `[A-Za-z0-9]' geschrieben werden, um eine Übereinstimmung mit
     allen alphanumerischen Zeichen zu erhalten.  Falls der verwendete
     Zeichensatz nun aber andere alphabetische Zeichen enthält, so würde
     vorstehendes Suchmuster keine Übereinstimmung mit diesen erbringen.
     Mit den POSIX Zeichenklassen kann nun aber `[[:alnum:]]'
     geschrieben werden, mit dem Resultat, daß _alle_ alphabetischen
     und numerischen Zeichen des verwendeten Zeichensatzes
     Übereinstimmungen erbringen würden.

     Zwei zusätzliche Spezialfolgen können in Zeichenlisten auftreten.
     Diese lassen sich auf Nicht-ASCII Zeichensätze anwenden, welche
     einzelne Symbole haben können (auch "vergleichende Elemente"(5)
     (*note Regexp Operatoren-Footnote-5::) genannt), die mit mehr als
     einem Zeichen dargestellt werden, ebensogut wie zahlreiche Zeichen,
     die gleichwertig für Vergleichs- oder Sortierungszwecke benutzt
     werden können.  (Zum Beispiel sind im Französischen das einfache
     `e' und ein _grave_ akzentuiertes `è' identisch.)

    Vergleichende Symbole
          Ein "vergleichendes Symbol"(6) (*note Regexp
          Operatoren-Footnote-6::) ist ein Multizeichen vergleichendes
          Element, das mit `[.' und `.]' umschlossen wird.  Wenn
          beispielsweise `ch' ein vergleichendes Element ist, so ist
          `[[.ch.]]' ein regexp, der auf dieses vergleichende Element
          paßt, wohingegen `[ch]' ein regexp ist, der entweder auf `c'
          oder auf `h' paßt.

    Gleichwertigkeitsklassen in regexp
          Eine "Gleichwertigkeitsklasse"(7) (*note Regexp
          Operatoren-Footnote-7::) ist eine Liste von gleichwertigen
          Zeichen, die mit `[=' und `=]' umschlossen sind.  Deswegen ist
          `[[=eè=]]' ein regexp, der entweder auf `e' oder `è' paßt.

     Diese Besonderheiten sind ein sehr wertvolles Hilfsmittel in nicht
     englischsprachig ausgerichteten Umgebungen.

     *Vorsicht:*

     Die Bibliotheksfunktionen, die von Gcal für die regulär-Ausdruck
     Vergleiche benutzt werden, erkennen derzeit nur POSIX
     Zeichenklassen (möglicherweise); sie erkennen weder vergleichende
     Elemente noch Gleichwertigkeitsklassen.

`[^ ...]'
     Bezeichnet eine "negierte Zeichenliste" bzw. "komplementäre
     Zeichenliste".  Das erste Zeichen nach der `[' Klammer _muß_ das
     `^' Zeichen sein.  Diese Zeichenliste paßt auf jedes Zeichen, das
     _nicht_ innerhalb der eckigen Klammern aufgeführt ist.  Zum
     Beispiel:

          [^0-9]

     paßt auf jedes Zeichen, das keine Ziffer ist.

`|'
     Das ist der "Auswahloperator", und dieser wird benutzt, um
     Alternativen zu vereinbaren.  Zum Beispiel:

          ^P|[0-9]

     paßt auf jeden string, der entweder mit `^P' oder mit `[0-9]'
     übereinstimmt.  Das bedeutet, daß Übereinstimmungen mit jeder
     Zeichenkette bestehen, die mit `P' beginnt oder eine Ziffer
     enthält.

     Die Alternative gilt für den größtmöglichen regulär-Ausdruck auf
     der jeweiligen Seite.  Mit anderen Worten, `|' hat den geringsten
     Vorrang aller regulär-Ausdruck Operatoren.

`(...)'
     Runde Klammern werden in regulären Ausdrücken genauso zum
     Gruppieren verwendet, wie in der Arithmetik.  Diese können benutzt
     werden, um reguläre Ausdrücke zu verketten, die den `|'
     Auswahloperator enthalten.
     Zum Beispiel paßt `@(samp|code)\{[^}]+\}' beiderseits auf
     `@code{foo}' und auf `@samp{bar}'.  (Das sind Texinfo
     Steueranweisungen zur Textformatierung.)

`*'
     Dieses Symbol bedeutet, daß der vorangehende reguläre Ausdruck so
     oft wiederholt wird, wie es notwendig ist, um eine Übereinstimmung
     zu finden.  Zum Beispiel:

          ph*

     verwendet das `*' Symbol zum vorangehenden `h', und prüft auf
     Übereinstimmungen, die sich aus einem `p', welches von einer
     beliebigen Anzahl von `h''s gefolgt wird, ergeben.  `ph*' paßt
     auch auf ein einzelnes `p', falls keine `h''s vorhanden sind.

     Das `*' Metazeichen wiederholt den _geringstmöglichen_
     vorangehenden Ausdruck.  (Benutzen Sie die runden Klammern, falls
     ein größerer Ausdruck wiederholt werden soll.)  Es werden so viele
     Wiederholungen wie möglich gefunden.  Zum Beispiel:

          gcal --filter-text='\(c[ad][ad]*r x\)' -f sample.rc -y

     gibt jeden Termin aus `sample.rc' aus, der einen Termintext der
     Form `(car x)', `(cdr x)', `(cadr x)', usw. enthält.  Beachten Sie
     das Entwerten der runden Klammern durch Voranstellen eines `\'
     Zeichens an diese.

`+'
     Dieses Symbol ist ähnlich wie `*', nur muß der vorangehende
     Ausdruck letztlich einmal gepaßt haben.  Das bedeutet, daß:

          ul+m

     zwar auf `ulm' und `ullm' passen würde, aber nicht auf `um',
     wohingegen `ul*m' auf alle drei vorstehenden Zeichenketten passen
     würde.  Hier ist eine einfachere Art, wie das letzte `*' Beispiel
     geschrieben werden kann:

          gcal --filter-text='\(c[ad]+r x\)' -f sample.rc -y

`?'
     Dieses Symbol ist ähnlich wie `*', aber der vorangehende Ausdruck
     kann entweder einmal gepaßt haben, oder nicht in Gänze.  Zum
     Beispiel:

          fe?d

     paßt nur auf `fed' und `fd', und nichts anderes.

`{N}'
`{N,}'
`{N,M}'
     Eine oder zwei Zahlen innerhalb geschweifter Klammern bezeichnen
     einen "Intervall-Ausdruck", der im POSIX Standard verfügbar ist.
     Falls eine Zahl in den Klammern vorhanden ist, so wird der
     vorangehende regexp N-fach wiederholt.  Wenn zwei Zahlen
     --separiert durch ein Komma-- in den Klammern vorhanden sind, so
     wird der vorangehende regexp N bis M-fach wiederholt.  Nun, falls
     eine Zahl --gefolgt von einem Komma-- in den Klammern vorhanden
     ist, dann wird der vorangehende regexp letztlich N-fach wiederholt.

    `ul{3}m'
          paßt auf `ulllm', aber nicht auf `ulm' oder `ullllm'.

    `ul{3,5}m'
          paßt nur auf `ulllm' oder `ullllm' oder `ulllllm'.

    `ul{2,}m'
          paßt auf `ullm' oder `ulllm' und so weiter.

GNU Software, die mit regulären Ausdrücken umgeht, unterstützt
zusätzlich weitere regulär-Ausdruck Operatoren.  Diese Operatoren sind
hier beschrieben.

Die meisten der zusätzlichen Operatoren sind geschaffen worden, damit
Übereinstimmungen in Wörtern festgestellt werden können.  Für unsere
Zwecke ist ein "Wort" eine Folge von einem oder mehreren Buchstaben,
Zahlen oder Unterstrichzeichen (`_').

`\w'
     Dieser Operator paßt auf jedes Zeichen, welches ein Wort
     konstituiert, d.h. jeder Buchstabe, Zahl oder Unterstrich.  Denken
     Sie es sich als eine Abkürzung für `[A-Za-z0-9_]' oder
     `[[:alnum:]_]'.

`\W'
     Dieser Operator paßt auf jedes Zeichen, welches kein Wort
     konstituiert.  Denken Sie es sich als eine Abkürzung für
     `[^A-Za-z0-9_]' oder `[^[:alnum:]_]'.

`\<'
     Dieser Operator paßt auf jeden leeren string zu Anfang eines
     Wortes.  Beispielsweise paßt `\<kennen' auf `kennen', aber nicht
     auf `erkennen'.

`\>'
     Dieser Operator paßt auf jede leere Zeichenkette zu Ende eines
     Wortes.  Zum Beispiel paßt `er\>' auf `er', aber nicht auf
     `erkennen'.

`\b'
     Dieser Operator paßt auf einen leeren string, der entweder zu
     Anfang oder zu Ende eines Wortes auftritt.  Zum Beispiel paßt
     `\bFalle?\b' entweder auf das einzelne Wort `Fall' oder auf das
     einzelne Wort `Falle'.

`\B'
     Dieser Operator paßt auf eine leere Zeichenkette, die innerhalb
     eines Wortes auftritt.  Mit anderen Worten, `\B' paßt auf einen
     leeren string, der zwischen zwei Zeichen auftritt, die ein Wort
     konstituieren.  Beispielsweise paßt `\Brechnet\B' auf
     `berechnete', aber es paßt nicht auf `so rechnet man'.  `\B' ist
     im Grunde genommen das genaue Gegenteil von `\b'.

Es gibt noch zwei weitere Operatoren, die auf einen Puffer anwendbar
sind.  Im Emacs ist ein "Puffer" natürlich ein Emacs Puffer.  In anderen
Programmen betrachten die regulär-Ausdruck Bibliotheksfunktionen, die
von Gcal benutzt werden, die gesamte Zeichenkette, welche auf
Übereinstimmungen hin untersucht werden soll, als den Puffer(8) (*note
Regexp Operatoren-Footnote-8::).

Für Gcal erbringen diese Operatoren keine neuen Fähigkeiten, da die `^'
und `$' Operatoren benutzt werden können, um Übereinstimmungen zu
Anfang und zu Ende von Zeichenketten festzustellen.  Sie sind nur
zwecks Kompatibilität zu anderer GNU Software bereitgestellt.

`\`'
     Dieser Operator paßt auf eine leere Zeichenkette zu Anfang eines
     Puffers.

`\''
     Dieser Operator paßt auf eine leere Zeichenkette zu Ende eines
     Puffers.

Die `*', `+' und `?' Operatoren und die geschweiften Klammern `{' und
`}' haben den höchsten Vorrang in regulären Ausdrücken, gefolgt von der
Verkettung, und abschließend dem `|' Operator.  Wie in der Arithmetik
üblich, so kann auch hier mittels Klammerung (runde Klammern) die
Gruppierung der Operatoren verändert werden.

Die Groß-/ Kleinschreibung ist normalerweise von Bedeutung in regulären
Ausdrücken, und zwar beiderseits beim Aufspüren von gewöhnlichen Zeichen
(d.h. Nicht-Metazeichen), und innerhalb Zeichenklassen.  Deswegen paßt
ein `w' in einem regulären Ausdruck nur auf einen `w' Kleinbuchstaben,
und nicht etwa auf einen `W' Großbuchstaben.

Der einfachste Weg, um ein groß-/ kleinschreibungsunabhängiges Zeichen
aufzuspüren, ist die Benutzung einer Zeichenliste: `[Ww]'.  Wie auch
immer, so kann es doch sehr lästig sein, falls soetwas des öfteren
gebraucht wird; und unglücklicherweise kann der reguläre Ausdruck
dadurch schwer lesbar werden.  Abhilfe bietet hier Gcal's
`--ignore-case' Option, welche die Unterschiede zwischen Groß- und
Kleinschreibung sowohl im regulären Ausdruck als auch im gesamten,
vollständig expandierten Text eines jeden *gültigen* Termins ignoriert.
*Note Termin Option `--ignore-case': x-ignore-case.


File: gcal.info,  Node: Regexp Operatoren-Footnotes,  Up: Regexp Operatoren

(1) Ein Leerzeichen ist zwar druckbar, aber nicht sichtbar, während ein
`a' Zeichen beides ist.

(2) Zeichen, die nicht Steuerzeichen sind.

(3) Zeichen, die weder Buchstabe, Zahl, Steuerzeichen noch Leerzeichen
sind.

(4) Solche wie das Leerzeichen, Tabulatorzeichen und
Seitenvorschubzeichen, um ein paar zu nennen.

(5) Im Englischen mit `collating elements' bezeichnet.

(6) Im Englischen mit `collating symbol' bezeichnet.

(7) Im Englischen mit `equivalence class' bezeichnet.

(8) Das ist der _Textteil_ einer Gcal Ressourcendateizeile.


File: gcal.info,  Node: Regexp (kurz),  Next: Spezialtexte (lang),  Prev: Regulaere Ausdruecke,  Up: Top

Zusammenfassung aller regulären Ausdrücke
*****************************************

Reguläre Ausdrücke basieren auf den POSIX ERAs (Erweiterte Reguläre
Ausdrücke).  Regexps werden aus Zeichen zusammengesetzt.  Hier ist eine
Kurzliste aller dieser Zeichen:

`C'
     paßt auf das Zeichen C (in der Annahme, das C keines der
     nachfolgend aufgeführten Zeichen ist).

`\C'
     paßt auf das textliche Zeichen C.

`.'
     paßt auf jedes Zeichen.

`^'
     paßt auf den Anfang einer Zeichenkette.

`$'
     paßt auf das Ende einer Zeichenkette.

`[ABC...]'
     paßt auf jedes der Zeichen ABC... (Zeichenliste).

`[[:SCHLüSSELWORT:]]'
     paßt auf jedes Zeichen in der Zeichenklasse SCHLüSSELWORT.
     Erlaubte Klassen sind `alnum', `alpha', `blank', `cntrl', `digit',
     `graph', `lower', `print', `punct', `space', `upper' und `xdigit'.

`[[.ELEMENT.]]'
     paßt auf das Multizeichen vergleichende ELEMENT.  Gcal unterstützt
     gegenwärtig keine vergleichenden Elemente.

`[[=LISTE=]]'
     paßt auf jedes der gleichwertigen Zeichen in LISTE.  Gcal
     unterstützt gegenwärtig keine Gleichwertigkeitsklassen.

`[^ABC...]'
     paßt auf jedes Zeichen, ausgenommen ABC... (negierte bzw.
     komplementäre Zeichenliste).

`R1|R2'
     paßt entweder auf R1 oder auf R2 (Alternative).

`R1R2'
     paßt auf R1, und dann auf R2 (Verkettung).

`R+'
     paßt auf ein R oder auf mehrere R's.

`R*'
     paßt auf kein R oder auf mehrere R's.

`R?'
     paßt auf kein R oder auf genau ein R.

`(R)'
     paßt auf R (Gruppierung).

`R{N}'
`R{N,}'
`R{N,M}'
     paßt auf letztlich N, N bis hin zu jeder Anzahl, oder N bis M
     Vorkommen von R (Intervall-Ausdrücke).

`\b'
     paßt auf eine leere Zeichenkette entweder zu Anfang oder zu Ende
     eines Wortes.

`\B'
     paßt auf die leere Zeichenkette innerhalb eines Wortes.

`\<'
     paßt auf die leere Zeichenkette zu Anfang eines Wortes.

`\>'
     paßt auf die leere Zeichenkette zu Ende eines Wortes.

`\w'
     paßt auf jedes Zeichen, welches ein Wort konstituiert
     (Alphanumerische Zeichen und der Unterstrich).

`\W'
     paßt auf jedes Zeichen, welches kein Wort konstituiert.

`\`'
     paßt auf die leere Zeichenkette zu Anfang eines Puffers(1) (*note
     Regexp (kurz)-Footnote-1::).

`\''
     paßt auf die leere Zeichenkette zu Ende eines Puffers.


File: gcal.info,  Node: Regexp (kurz)-Footnotes,  Up: Regexp (kurz)

(1) Identisch mit dem _Textteil_ einer Ressourcendateizeile von Gcal.


File: gcal.info,  Node: Spezialtexte (lang),  Next: Spezialtexte (kurz),  Prev: Regexp (kurz),  Up: Top

Beschreibung aller `%?'... Spezialtexte
***************************************

* Menu:

* Ausschliessen::   Datum ausschließen.
* Ersetzen::        Texte ersetzen.
* Shell Kommando::  Shell Kommando ausführen.

Die im Textteil einer Zeile der Gcal Ressourcendatei verwendbaren
`%?'... Spezialtexte können grob in drei Kategorien eingeteilt werden.
So gibt es Spezialtexte, welche die Ausgabe von Terminen in bestimmten
Fällen unterdrücken.  Andere werden durch besondere Texte ersetzt, und
noch andere veranlassen die shell dazu, externe Kommandos auszuführen.
*Note `%?'... Spezialtexte: Spezialtexte, für eine allgemeine
Beschreibung der Spezialtexte, die im Textteil einer Zeile von Gcal
Ressourcendateien auftreten dürfen.

Bei einigen dieser Spezialtexte darf noch optional eine Formatanweisung
(im weiteren mit FORMAT bezeichnet) angegeben werden, welche die
Darstellung des expandierten Spezialtextes beeinflußt.  *Note
Formatanweisung::, für die ausführliche Beschreibung der
Formatanweisung und ihrer Komponenten.  Bei Spezialtexten, die kein
FORMAT aufweisen dürfen, wird eine eventuell angegebene Formatanweisung
von Gcal ignoriert und nicht ausgegeben.

Aber auch solche Spezialtexte können mittels einer Formatanweisung von
Gcal besonders dargestellt werden, und zwar durch eine indirekte
Methode.  Man weist einfach einer Textvariablen den Spezialtext
exklusiv zu und gibt diese dann, mit einer Formatanweisung versehen,
aus.  Allerdings ist dabei zu beachten, daß die Feldbreitenkomponente
der Formatanweisung so zu wählen ist, daß sie sich auf den zugewiesenen
Inhalt der Textvariablen bezieht, sofern die Formatanweisung eine
Festformat-Komponente aufweist.  Der zugewiesene Inhalt an die
Textvariable ist nämlich nur der Spezialtext, und nicht dessen
expandiertes Ergebnis.  Gcal muß derart vorgehen, da ja der in der
Textvariablen verborgene Spezialtext nicht nur auf ein bestimmtes Datum
angewendet (hier: ausgegeben) werden soll, sondern unter Umständen auch
auf mehrere, und zwar angepaßt an das jeweilige Datum, an dem er
referenziert wird.  Somit befindet sich in der Textvariablen ein
Spezialtext, der eine bestimmte Länge hat, und es existiert eine
Formatanweisung, dessen Feldbreitenkomponente auf das expandierte
Ergebnis des Spezialtextes wirken soll.  Allerdings weiß Gcal zum
Zeitpunkt der Zuweisung des Spezialtextes an die Textvariable nicht,
wie lang das expandierte Ergebnis sein wird, da diese Expansion erst zu
einem sehr viel späteren Zeitpunkt im Programmablauf stattfindet.  Von
daher sollte in einem solchen Fall die Feldbreitenkomponente der
Formatanweisung mindestens die Länge des Spezialtextes betragen,
andernfalls wird dieser durch die internen Mechanismen, die die
Expansion bewirken, verkrüppelt und nicht korrekt expandiert und
dargestellt.

Bei denjenigen Spezialtexten, deren expandierte Darstellung durch ein
optionales FORMAT beeinflußt werden kann, sind in diesem Anhang
natürlich nicht alle Möglichkeiten aufgeführt, welche die
Formatanweisung hinsichtlich der Darstellung bietet, sondern nur einige
wenige exemplarisch.

Und bei einigen dieser Spezialtexte darf auch noch optional ein
einfaches oder besonderes Datumargument (im weiteren mit DATUM
bezeichnet) oder ein sonstiges Argument (im weiteren mit ARGUMENT
bezeichnet) angegeben werden.  Wenn ein Spezialtext direkt von einem
DATUM Argument gefolgt wird, so muß DATUM einem der nachstehenden
Datumformate entsprechen:

   * `JJJJ[MM[TT|WWWN]]'

   * `JJJJ*d|wN[WWW]'

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

Spezialtexte, die ein DATUM Argument annehmen dürfen, *müssen* stets
von einem _whitespace_ Zeichen gefolgt werden, welches seinerseits in
der Ausgabe entfernt wird, und zwar unabhängig davon, ob DATUM
angegeben wurde oder nicht!

*Note Zusammenfassung aller `%?'... Spezialtexte: Spezialtexte (kurz),
für eine Kurzdarstellung aller verwendbaren Spezialtexte.


File: gcal.info,  Node: Ausschliessen,  Next: Ersetzen,  Prev: Spezialtexte (lang),  Up: Spezialtexte (lang)

`%?'... Spezialtexte um Datum auszuschließen
============================================

* Menu:

* Ausschliessen mit Datumargument::
* Ausschliessen ohne Argument::

`%?'... Spezialtexte zum Ausschließen von Zeitpunkten oder Zeiträumen
sind sehr nützlich, wenn sie zusammen mit Datumbereichen verwendet
werden (*note Bereiche von Tagen::).  Wird der Termintext ausgegeben,
so wird stets der gesamte Spezialtext in der Ausgabe unterdrückt.


File: gcal.info,  Node: Ausschliessen mit Datumargument,  Next: Ausschliessen ohne Argument,  Prev: Ausschliessen,  Up: Ausschliessen

Ausschließen mit Datumargument `%?[DATUM]' Spezialtexte
-------------------------------------------------------

* Menu:

* Inklusive Datum Zeitraum::
* Exklusive Datum Zeitraum::

Zunächst einmal kann ein "inklusive Datum" Zeitraum `%?[DATUM]'
Spezialtext angegeben werden, mit der Wirkung, daß nur die Termine, die
in diesem Zeitraum liegen, ausgegeben werden.  Und die Angabe eines
"exklusive Datum" Zeitraums `%?[DATUM]' Spezialtexts bewirkt, daß alle
Termine, die in diesem Zeitraum liegen, nicht ausgegeben werden.

Geschickt kombiniert, bieten sich diese Spezialtexte als wirksame Filter
an, mit deren Hilfe sich spezielle Zeiträume sehr flexibel definieren
lassen können, zum Beispiel:

     0*d1#999 Jeder Tag des Jahres: Von Januar...August ausgenommen April\
              %i00001#00008 %e00004#00004
     ;
     0*d1#999 Jeder Tag des Jahres: Von 1991...1993 und ab 1996\
              ausgenommen Februar 1992 und aller September\
              %i1991#1993 %i1996# %e19922#19922 %e00009#00009


File: gcal.info,  Node: Inklusive Datum Zeitraum,  Next: Exklusive Datum Zeitraum,  Prev: Ausschliessen mit Datumargument,  Up: Ausschliessen mit Datumargument

Inklusive Datum Zeitraum `%i[DATUM][#[DATUM]]' Spezialtext
..........................................................

`%i[DATUM][#[DATUM]]' bezeichnet einen inklusive Datum Zeitraum, d.h.
alle Daten, die in dem gegebenen Zeitraum liegen, sind gültig und
werden ausgegeben.  Das bedeutet natürlich, daß alle Termine, die nicht
in diesem Zeitraum liegen, ungültig sind und somit auch nicht
ausgegeben werden.

Das erste angegebene Datum bestimmt das "Startdatum" eines Termins,
d.h. das erste Datum, an dem dieser Termin auftreten darf.  Für das
Startdatum gelten folgende Regeln hinsichtlich bestimmter
Auslassungswerte, verdeutlicht am `JJJJ[MM[TT|WWWN]]' Datumformat:

   * 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, bei `99' der Dezember.

   * 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, bei `99' der letzte Tag des Monats MM.

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

Das zweite angegebene Datum bestimmt das "Endedatum" eines Termins,
d.h. das letzte Datum, an dem dieser Termin auftreten darf.  Für das
Endedatum gelten folgende Regeln hinsichtlich bestimmter
Auslassungswerte, ebenfalls verdeutlicht am `JJJJ[MM[TT|WWWN]]'
Datumformat:

   * 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, bei `99' der Dezember.

   * 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, bei `99' der letzte Tag des Monats MM.

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

Für die anderen erlaubten Datumformate gelten die vorstehenden Regeln
sinngemäß!

Wenn das Startdatum, welches im `%i...' Spezialtext kodiert ist, größer
dem Endedatum ist, so wird der `%i...' Spezialtext ignoriert.

Ist weder Startdatum noch Endedatum angegeben, also nur `%i', so gilt
der implizite Zeitraum 1'ter Januar 1...31'ter Dezember 9999
(00010101...99991231).

Ist nur das Startdatum angegeben, also entweder `%iDATUM' oder
`%iDATUM#', so gilt das implizite Endedatum 31'ter Dezember 9999
(99991231).

Ist nur das Endedatum angegeben, also `%i#DATUM', so gilt das implizite
Startdatum 1'ter Januar 1 (00010101).

Zum Beispiel:

     0d*1#999 Jeder Tag des Jahres: nur April und Juli\
              %i00004#00004 %i00007#00007
     ;
     0*d1#999 Jeder Tag des Jahres: von Januar...Oktober\
              %i#000010
     ;
     0*d1#999 Jeder Tag des Jahres: ab August 1990\
              %i19908
     ;
     0*d1#999 Jeder Tag des Jahres: von August...Dezember\
              %i00008
     ;
     0*d1#999 Jeder Tag des Jahres: nur heute%i0@t#0@t


File: gcal.info,  Node: Exklusive Datum Zeitraum,  Prev: Inklusive Datum Zeitraum,  Up: Ausschliessen mit Datumargument

Exklusive Datum Zeitraum `%e[DATUM][#[DATUM]]' Spezialtext
..........................................................

`%e[DATUM][#[DATUM]]' bezeichnet einen exklusive Datum Zeitraum, d.h.
alle Daten, die in dem gegebenen Zeitraum liegen, sind ungültig und
werden nicht ausgegeben.  Das bedeutet natürlich, daß alle Termine, die
nicht in diesem Zeitraum liegen, gültig sind und somit auch ausgegeben
werden.

Das erste angegebene Datum bestimmt das Startdatum eines Termins, d.h.
das erste Datum, an dem dieser Termin auftreten darf.  Für das
Startdatum gelten folgende Regeln hinsichtlich bestimmter
Auslassungswerte, verdeutlicht am `JJJJ[MM[TT|WWWN]]' Datumformat:

   * 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, bei `99' der Dezember.

   * 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, bei `99' der letzte Tag des Monats MM.

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

Das zweite angegebene Datum bestimmt das Endedatum eines Termins, d.h.
das letzte Datum, an dem dieser Termin auftreten darf.  Für das
Endedatum gelten folgende Regeln hinsichtlich bestimmter
Auslassungswerte, ebenfalls verdeutlicht am `JJJJ[MM[TT|WWWN]]'
Datumformat:

   * 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, bei `99' der Dezember.

   * 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, bei `99' der letzte Tag des Monats MM.

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

Für die anderen erlaubten Datumformate gelten die vorstehenden Regeln
sinngemäß!

Wenn das Startdatum, welches im `%e...' Spezialtext kodiert ist, größer
dem Endedatum ist, so wird der `%e...' Spezialtext ignoriert.

Ist weder Startdatum noch Endedatum angegeben, also nur `%e', so gilt
der implizite Zeitraum 1'ter Januar 1...31'ter Dezember 9999
(00010101...99991231).

Ist nur das Startdatum angegeben, also entweder `%eDATUM' oder
`%eDATUM#', so gilt das implizite Endedatum 31'ter Dezember 9999
(99991231).

Ist nur das Endedatum angegeben, also `%e#DATUM', so gilt das implizite
Startdatum 1'ter Januar 1 (00010101).

Zum Beispiel:

     0d*1#999 Jeder Tag des Jahres: ausgenommen April und Juli\
             %e00004#00004 %e00007#00007
     ;
     0*d1#999 Jeder Tag des Jahres: ausgenommen Januar...Oktober\
              %e#000010
     ;
     0*d1#999 Jeder Tag des Jahres: bis Juli 1990\
              %e19908
     ;
     0*d1#999 Jeder Tag des Jahres: ausgenommen August...Dezember\
              %e00008
     ;
     0*d1#999 Jeder Tag des Jahres: ausgenommen heute%e0@t#0@t


File: gcal.info,  Node: Ausschliessen ohne Argument,  Prev: Ausschliessen mit Datumargument,  Up: Ausschliessen

Ausschließen ohne Argument `%?' Spezialtexte
--------------------------------------------

* Menu:

* Inklusive Tag Zeitraum::
* Exklusive Tag Zeitraum::

Zunächst einmal kann ein "inklusive Tag" Zeitraum `%?' Spezialtext
angegeben werden, mit der Wirkung, daß nur die Termine, die in diesem
Zeitraum liegen, ausgegeben werden.  Und die Angabe eines "exklusive
Tag" Zeitraums `%?' Spezialtexts bewirkt, daß alle die Termine, die
nicht in diesem Zeitraum liegen, ausgegeben werden.

Geschickt kombiniert, bieten auch diese Spezialtexte wirksame Filter,
mit deren Hilfe sehr spezielle Zeiträume definiert werden können, zum
Beispiel:

     0*d1#999 Jeder Tag des Jahres: Von Montags...Freitags\
              ausgenommen Mittwochs und aller gesetzlichen Feiertage\
              %r%F%V
     ;
     00001001#9999 Jeder Tag im letzten Quartal des Jahres: Alle Feiertage\
                   die nicht auf einen Sonntag fallen%x %P


File: gcal.info,  Node: Inklusive Tag Zeitraum,  Next: Exklusive Tag Zeitraum,  Prev: Ausschliessen ohne Argument,  Up: Ausschliessen ohne Argument

Inklusive Tag Zeitraum `%?' Spezialtexte
........................................

Folgende inklusive Tag Zeiträume `%?' Spezialtexte werden
berücksichtigt, wobei in diesem Zusammenhang mit _inklusive_ der
Zeitraum gemeint ist, welcher nicht ausgeschlossen wird:

`%v'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht als
     gesetzlicher Feiertag in der _ewigen Feiertagsliste_ aufgeführt
     ist.

`%x'
     Bewirkt den Ausschluß eines Termins, falls dieser weder als
     gesetzlicher Feiertag noch als Gedenktag in der _ewigen
     Feiertagsliste_ aufgeführt ist.

`%a'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Montag fällt.

`%c'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Dienstag fällt.

`%f'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Mittwoch fällt.

`%g'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Donnerstag fällt.

`%h'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Freitag fällt.

`%l'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Samstag fällt.

`%p'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Sonntag fällt.

`%q'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Montag...Donnerstag fällt.

`%r'
     Bewirkt den Ausschluß eines Termins, falls dieser nicht auf einen
     Montag...Freitag fällt.


File: gcal.info,  Node: Exklusive Tag Zeitraum,  Prev: Inklusive Tag Zeitraum,  Up: Ausschliessen ohne Argument

Exklusive Tag Zeitraum `%?' Spezialtexte
........................................

Folgende exklusive Tag Zeiträume `%?' Spezialtexte werden
berücksichtigt, wobei in diesem Zusammenhang mit _exklusive_ der
Zeitraum gemeint ist, welcher ausgeschlossen wird:

`%V'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen Tag
     fällt, der als gesetzlicher Feiertag in der _ewigen
     Feiertagsliste_ aufgeführt ist.

`%X'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen Tag
     fällt, der entweder als gesetzlicher Feiertag oder als Gedenktag
     in der _ewigen Feiertagsliste_ aufgeführt ist.

`%A'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen Montag
     fällt.

`%C'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen
     Dienstag fällt.

`%F'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen
     Mittwoch fällt.

`%G'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen
     Donnerstag fällt.

`%H'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen Freitag
     fällt.

`%L'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen Samstag
     fällt.

`%P'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen Sonntag
     fällt.

`%Q'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen
     Montag...Donnerstag fällt.

`%R'
     Bewirkt den Ausschluß eines Termins, falls dieser auf einen
     Montag...Freitag fällt.


File: gcal.info,  Node: Ersetzen,  Next: Shell Kommando,  Prev: Ausschliessen,  Up: Spezialtexte (lang)

`%?'... Spezialtexte zum Textersatz
===================================

* Menu:

* Ersetzen mit Datumargument::
* Ersetzen mit anderem Argument::
* Ersetzen ohne Argument::

`%?'... Spezialtexte, die zur Programmlaufzeit durch besonderen Text
ersetzt werden, bewirken das Einstreuen von Daten in den Termintext,
deren Ausprägung im wesentlichen von den Kommandozeilenargumenten
abhängen, welche bei Programmausführung angegeben worden sind.  Wird
der Termintext ausgegeben, so wird stets der gesamte Spezialtext in der
Ausgabe entsprechend ersetzt.

Geschickt kombiniert, bieten sich auch diese Spezialtexte als wirksame
Mechanismen an, mit deren Hilfe sich spezielle Texte sehr flexibel
erzeugen lassen können, zum Beispiel:

     0*d1#999 Jeder Tag des Jahres: Heute ist %K, der %n (%N)

