Provided by: manpages-de-dev_4.21.0-2_all bug

BEZEICHNUNG

       regcomp, regexec, regerror, regfree - Regulärer-Ausdruck-Funktionen gemäß POSIX

BIBLIOTHEK

       Standard-C-Bibliothek (libc, -lc)

ÜBERSICHT

       #include <regex.h>

       int regcomp(regex_t *restrict preg, const char *restrict regaus,
                   int kschalter);
       int regexec(const regex_t *restrict preg, const char *restrict zeichenkette,
                   size_t ntreffer, regmatch_t ptreffer[restrict .ntreffer],
                   int aschalter);

       size_t regerror(int fehlercode, const regex_t *restrict preg,
                   char fehlerpuf[restrict .fehlerpufgröße], size_t fehlerpufgröße);
       void regfree(regex_t *preg);

BESCHREIBUNG

   Kompilierung regulärer Ausdrücke gemäß POSIX
       regcomp()  wird  zur Kompilierung eines regulären Ausdrucks in eine Form verwandt, die für
       nachfolgende regexec()-Suchen geeignet ist.

       regcomp() wird preg, ein Zeiger auf einen Musterpuffer-Speicherbereich, regaus, ein Zeiger
       auf eine Zeichenkette mit Nullbyte am Ende und kschalter, Schalter zur Bestimmung des Typs
       der Kompilierung, übergeben.

       Eine Suche mit regulären Ausdrücken muss mittels kompilierter Musterpuffer erfolgen, daher
       muss   regexec()   immer   die   Adresse   eines  regcomp()-initialisierten  Musterpuffers
       bereitgestellt werden.

       kschalter ist das bitweises ODER von null oder mehr der Folgenden:

       REG_EXTENDED
              Die Syntax der erweiterten regulären Ausdrücke gemäß POSIX bei  der  Interpretation
              von  regaus  verwenden.  Falls  nicht  gesetzt,  werden die grundlegenden regulären
              Ausdrücke gemäß POSIX verwandt.

       REG_ICASE
              Keine   Unterscheidung   der   Groß-/Kleinschreibung   durchführen.    Nachfolgende
              regexec()-Suchen   mit   diesem   Musterpuffer   werden  die  Groß-/Kleinschreibung
              ignorieren.

       REG_NOSUB
              Positionen von Treffern nicht berichten. Die Argumente ntreffer  und  ptreffer  von
              regexec()  werden ignoriert, falls der übergebene Musterpuffer mit diesem gesetztem
              Schalter kompiliert wurde.

       REG_NEWLINE
              Passt-auf-jedes-Zeichen-Operator passt nicht auf einen Zeilenumbruch.

              Eine Liste nichtpassender Zeichen ([^…]), die keinen Zeilenumbruch  enthält,  passt
              nicht auf einen Zeilenumbruch.

              Passt-auf-Zeilenanfang-Operator  (^)  passt  auf die leere Zeichenkette direkt nach
              einem Zeilenumbruch, unabhängig davon, ob  die  Ausführungsschalter  von  regexec()
              (eflags) REG_NOTBOL enthalten.

              Passt-auf-Zeilenende-Operator ($) passt auf die leere Zeichenkette direkt vor einem
              Zeilenumbruch, unabhängig davon, ob eflags REG_NOTEOL enthält.

   Vergleiche POSIX-regulärer Ausdrücke
       regexec()  wird  zum  Vergleich  einer  auf  Nullbyte  endenden   Zeichenkette   mit   dem
       vorkompilierten   Musterpuffer   preg   verwandt.   ntreffer   und   ptreffer  werden  zur
       Bereitstellung von Informationen bezüglich der Position von Treffern  verwandt.  aschalter
       ist das bitweise ODER von null oder mehreren der folgenden Schalter:

       REG_NOTBOL
              Der  Passt-auf-Zeilenanfang-Operator  schlägt  bei Vergleich immer fehl (siehe aber
              auch obigen  Kompilierungsschalter  REG_NEWLINE).  Dieser  Schalter  kann  verwandt
              werden,  wenn verschiedene Anteile einer Zeichenkette an regexec() übergeben werden
              und der Anfang einer Zeichenkette nicht als Anfang einer Zeile interpretiert werden
              soll.

       REG_NOTEOL
              Der Passt-auf-Zeilenende-Operator schlägt bei Vergleich immer fehl (siehe aber auch
              obigen Kompilierungsschalter REG_NEWLINE).

       REG_STARTEND
              ptreffer[0] als  Eingabezeichenkette,  beginnend  bei  Byte  ptreffer[0].rm_so  und
              endend   by  Byte  ptreffer[0].rm_eo,  verwenden.  Dies  ermöglicht  den  Vergleich
              eingebetteter Nullbytes und vermeidet ein strlen(3) bei  großen  Zeichenketten.  Es
              verwendet  bei  der  Eingabe  ntreffer nicht und ändert die Verarbeitung REG_NOTBOL
              oder REG_NEWLINE nicht. Dieser Schalter ist eine BSD-Erweiterung,  nicht  in  POSIX
              vorhanden.

   Byte-Versätze
       Es  ist  möglich, die Übereinstimmungs-Adressierungsinformationen zu erhalten, falls nicht
       REG_NOSUB für  die  Kompilierung  des  Musterpuffers  verwandt  wurde.  ptreffer  muss  so
       dimensoniert  sein,  dass  es  mindestens  ntreffer  Elemente  enthält. Diese werden durch
       regexec() durch Teilzeichenketten-Übereinstimmungsadressen gefüllt. Die Versätze  des  bei
       der iten offenen Klammer beginnenden Unterausdrucks werden in ptreffer[i] gespeichert. Die
       Übereinstimmungsadresse des gesamten regulären Ausdrucks wird in ptreffer[0]  gespeichert.
       (Beachten  Sie,  dass  ptreffer  mindestens  N+1  sein  muss,  um  den  Versatz  des  Nten
       Unterausdruckstreffers zurückzuliefern.) Alle nicht verwandten Strukturelemente werden den
       Wert -1 enthalten.

       Die Struktur regmatch_t, die der Typ von ptreffer ist, wird in <regex.h> definiert.

           typedef struct {
               regoff_t rm_so;
               regoff_t rm_eo;
           } regmatch_t;

       Jedes  Element  rm_so,  das  nicht  -1  ist,  zeigt  den Startversatz des nächsten größten
       Teilzeichenkettentreffers innerhalb der Zeichenkette an. Das relative Element rm_eo  zeigt
       den  Endversatz  des  Treffers  an;  dies ist das erste Zeichen nach dem übereinstimmenden
       Text.

   Fehlerberichterstattung gemäß POSIX
       Zur  Umwandlung  der  von  regcomp()  und  regexec()  zurückgelieferten   Fehlercodes   in
       Fehlermeldungszeichenketten wird regerror() verwandt.

       regerror()  wird der Fehlercode fehlercode, der Musterzeichenkettenpuffer preg, ein Zeiger
       auf  einen  Zeichenkettenpuffer  fehlerpuf  und   die   Größe   des   Zeichenkettenpuffers
       fehlerpufgröße  übergeben.  Sie liefert die Größe des fehlerpuf zurück, die benötigt wird,
       um die mit Nullbyte abgeschlossene Fehlermeldungszeichenkette zu enthalten.  Falls  sowohl
       fehlerpuf als auch fehlerpufgröße von null verschieden sind, wird fehlerpuf mit den ersten
       fehlerpufgröße - 1 Zeichen der Fehlermeldung  und  einem  abschließenden  Nullbyte  (»\0«)
       aufgefüllt.

   Musterpufferfreigabe gemäß POSIX
       Wird  regfree()  ein  vorkompilierter  Puffer,  preg, bereitgestellt, dann wird es den vom
       Musterpuffer durch den Kompilierprozess regcomp() belegten Speicher freigeben.

RÜCKGABEWERT

       regcomp() liefert Null bei einer erfolgreichen  Kompilierung  oder  einen  Fehlercode  bei
       einem Fehlschlag zurück.

       regexec()  liefert  Null  bei  einem  erfolgreichen  Treffer  oder  REG_NOMATCH  bei einem
       Fehlschlag zurück.

FEHLER

       Von regcomp() können die folgenden Fehler zurückgeliefert werden:

       REG_BADBR
              Ungültige Verwendung des Rückwärtsverweis-Operators.

       REG_BADPAT
              Ungültige Verwendung des Muster-Operators (wie Gruppierung oder Liste).

       REG_BADRPT
              Ungültige Verwendung des Wiederholungs-Operators wie die  Verwendung  von  »*«  als
              erstes Zeichen.

       REG_EBRACE
              Fehlender öffenender oder schließender Intervall-Operator (geschweifte Klammer).

       REG_EBRACK
              Fehlender öffenender oder schließender Listen-Operator (eckige Klammer).

       REG_ECOLLATE
              Ungültiges Sortierelement.

       REG_ECTYPE
              Unbekannter Zeichenklassenname.

       REG_EEND
              Nichtspezifizierter Fehler. Dies wird durch POSIX.2 nicht definiert.

       REG_EESCAPE
              Abschließender Rückwärtsschrägstrich.

       REG_EPAREN
              Fehlender öffenender oder schließender Gruppen-Operator (runde Klammer).

       REG_ERANGE
              Ungültige  Verwendung des Bereichs-Operators; beispielsweise tritt der Endpunkt des
              Bereichs vor dem Anfangspunkt auf.

       REG_ESIZE
              Kompilierte reguläre Ausdrücke benötigen einen Musterpuffer, der größer  als  64 kB
              ist. Dies ist in POSIX.2 nicht definiert.

       REG_ESPACE
              Die Routinen für reguläre Ausdrücke hatten nicht genug Speicher.

       REG_ESUBREG
              Ungültige Rückwärtsreferenz auf einen Unterausdruck.

ATTRIBUTE

       Siehe attributes(7) für eine Erläuterung der in diesem Abschnitt verwandten Ausdrücke.

       ┌────────────────────────────────────────────────┬───────────────────────┬────────────────┐
       │SchnittstelleAttributWert           │
       ├────────────────────────────────────────────────┼───────────────────────┼────────────────┤
       │regcomp(), regexec()                            │ Multithread-Fähigkeit │ MT-Safe locale │
       ├────────────────────────────────────────────────┼───────────────────────┼────────────────┤
       │regerror()                                      │ Multithread-Fähigkeit │ MT-Safe env    │
       ├────────────────────────────────────────────────┼───────────────────────┼────────────────┤
       │regfree()                                       │ Multithread-Fähigkeit │ MT-Safe        │
       └────────────────────────────────────────────────┴───────────────────────┴────────────────┘

STANDARDS

       POSIX.1-2001, POSIX.1-2008.

BEISPIELE

       #include <stdint.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <regex.h>

       #define ARRAY_SIZE(arr) (sizeof((arr)) / sizeof((arr)[0]))

       static const char *const str =
               "1) John Driverhacker;\n2) John Doe;\n3) John Foo;\n";
       static const char *const re = "John.*o";

       int main(void)
       {
           static const char *s = str;
           regex_t     regex;
           regmatch_t  pmatch[1];
           regoff_t    off, len;

           if (regcomp(&regex, re, REG_NEWLINE))
               exit(EXIT_FAILURE);

           printf("Zeichenkette = \"%s\"\n", str);
           printf("Treffer:\n");

           for (unsigned int i = 0; ; i++) {
               if (regexec(&regex, s, ARRAY_SIZE(pmatch), pmatch, 0))
                   break;

               off = pmatch[0].rm_so + (s - str);
               len = pmatch[0].rm_eo - pmatch[0].rm_so;
               printf("#%zu:\n", i);
               printf("Versatz = %jd; Länge = %jd\n", (intmax_t) off,
                       (intmax_t) len);
               printf("Teilzeichenkette = \"%.*s\"\n", len, s + pmatch[0].rm_so);

               s += pmatch[0].rm_eo;
           }

           exit(EXIT_SUCCESS);
       }

SIEHE AUCH

       grep(1), regex(7)

       Das Handbuch der Glibc, Abschnitt Regular Expressions

ÜBERSETZUNG

       Die    deutsche    Übersetzung   dieser   Handbuchseite   wurde   von   Helge   Kreutzmann
       <debian@helgefjell.de> erstellt.

       Diese Übersetzung ist Freie Dokumentation;  lesen  Sie  die  GNU  General  Public  License
       Version  3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ oder neuer bezüglich der Copyright-
       Bedingungen. Es wird KEINE HAFTUNG übernommen.

       Wenn Sie Fehler in der Übersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-
       Mail an die Mailingliste der Übersetzer ⟨debian-l10n-german@lists.debian.org⟩.