Provided by: manpages-de-dev_4.23.1-1_all 
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[_Nullable restrict .ntreffer],
int aschalter);
size_t regerror(int fehlercode, const regex_t *_Nullable restrict preg,
char fehlerpuf[_Nullable restrict .fehlerpufgröße],
size_t fehlerpufgröße);
void regfree(regex_t *preg);
typedef struct {
size_t re_nsub;
} regex_t;
typedef struct {
regoff_t rm_so;
regoff_t rm_eo;
} regmatch_t;
typedef /* … */ regoff_t;
BESCHREIBUNG
Kompilierung
regcomp() wird zur Kompilierung eines regulären Ausdrucks in eine Form verwandt, die für
nachfolgende regexec()-Suchen geeignet ist.
Im Erfolgsfall wird der Musterpuffer bei *preg initialisert. regaus ist eine auf Nullbyte
endende Zeichenkette. Die Locale muss die gleiche wie bei der Ausführung von regexec()
sein.
Nachdem regcomp() erfolgreich war, hält preg->re_nsub die Anzahl der Unterausdrücke in
regaus. Daher reicht es aus, ein Wert preg->re_nsub + 1 als ntreffer an regexec() zu
übergeben, um alle Treffer einzufangen.
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
Nur den Gesamterfolg berichten. regexec() wird nur ptreffer für REG_STARTEND
verwenden und ntreffer ignorieren.
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.
Vergleich
regexec() wird zum Vergleich einer auf Nullbyte endenden Zeichenkette mit dem kompilierten
Musterpuffer in *preg, der durch regexec() initialisiert sein muss. 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
Passt auf [Zeichenkette + ptreffer[0].rm_so, Zeichenkette + ptreffer[0].rm_eo)
anstelle von [Zeichenkette, Zeichenkette + strlen(Zeichenkette)). Dies ermöglicht
den Vergleich mit Nullbytes und vermeidet ein strlen(3) bei Zeichenketten mit
bekannter Länge. Falls Treffer zurückgeliefert wurden (REG_NOSUB wurde nicht an
regcomp() übergeben, der Vergleich war erfolgreich und ntreffer > 0) überschreiben
sie wie gewöhnlich ptreffer und der Vergleichsversatz bleibt relativ zu
zeichenkette (nicht zeichenkette + ptreffer[0].rm_so). Dieser Schalter ist eine
BSD-Erweiterung und in POSIX nicht vorhanden.
Vergleichs-Versätze
Außer REG_NOSUB wurde an regcomp() übergeben, ist es möglich, den Ort des Treffers
innerhalb von zeichenkette zu bestimmen: regexec() füllt ntreffer Elemente von ptreffer
mit Ergebnissen: ptreffere[0] entspricht dem gesamten Treffer, ptreffer[1] dem ersten
Unterausdruck usw. Falls es mehr Treffer als ntreffer gab, werden diese verworfen; falls
weniger, werden unbenutzte Elemente von ptreffer mit -1en gefüllt.
Jeder zurückgelieferte gültige (nicht -1) Treffer entspricht dem Bereich [zeichenkette +
rm_so, zeichenkette + rm_eo).
regoff_t ist ein vorzeichenbehafteter Ganzzahltyp, der den größten Wert speichern kann,
der in entweder dem Typ ptrdiff_t oder dem Typ ssize_t gespeichert werden kann.
Fehlerberichterstattung
Zur Umwandlung der von regcomp() und regexec() zurückgelieferten Fehlercodes in
Fehlermeldungszeichenketten wird regerror() verwandt.
Falls preg kein NULL-Zeiger ist, muss fehlercode der neuste Fehlercode sein, der von einer
Aktion auf preg zurückgeliefert wurde.
Falls fehlerpufgröße nicht 0 ist, werden bis zu fehlerpufgröße an Bytes in fehlerpuf
kopiert; die Fehlerzeichenkette endet immer auf einem Nullbyte und wird abgeschnitten,
damit sie passt.
Freigabe
regfree() deinitialisiert den Musterpuffer bei *preg und gibt sämtlichen zugeordneten
Speicher frei. *preg muss mittels regcomp() initialisiert worden sein.
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.
regerror() liefert die Größe des Puffers zurück, der zum Halten der Zeichenkette benötigt
wird.
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 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 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.
┌──────────────────────────────────────────────┬───────────────────────┬──────────────────┐
│Schnittstelle │ Attribut │ Wert │
├──────────────────────────────────────────────┼───────────────────────┼──────────────────┤
│regcomp(), regexec() │ Multithread-Fähigkeit │ MT-Sicher locale │
├──────────────────────────────────────────────┼───────────────────────┼──────────────────┤
│regerror() │ Multithread-Fähigkeit │ MT-Sicher env │
├──────────────────────────────────────────────┼───────────────────────┼──────────────────┤
│regfree() │ Multithread-Fähigkeit │ MT-Sicher │
└──────────────────────────────────────────────┴───────────────────────┴──────────────────┘
STANDARDS
POSIX.1-2008.
GESCHICHTE
POSIX.1-2001.
Vor POSIX.1-2008 musste regoff_t in der Lage sein, den größten Wert abzuspeichern, der in
entweder dem Typ off_t oder dem Typ ssize_t gespeichert werden kann.
WARNUNGEN
re_nsub muss nur initialisiert sein, falls REG_NOSUB nicht festgelegt wurde, aber alle
bekannten Implementierungen initialisieren sie trotzdem.
Sowohl regex_t als auch regmatch_t dürfen (und haben) weitere Mitglieder, in beliebiger
Reihenfolge. Referenzieren Sie sie immer über den Namen.
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(®ex, re, REG_NEWLINE))
exit(EXIT_FAILURE);
printf("Zeichenkette = \"%s\"\n", str);
printf("Treffer:\n");
for (unsigned int i = 0; ; i++) {
if (regexec(®ex, 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⟩.