.\" Copyright, the authors of the Linux man-pages project
.\"
.\" SPDX-License-Identifier: Linux-man-pages-copyleft
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH printf.h 3head "17. Mai 2025" "Linux man\-pages 6.20" 
.SH BEZEICHNUNG
printf.h, \%register_printf_specifier, \%register_printf_modifier,
\%register_printf_type, \%printf_function, \%printf_arginfo_size_function,
\%printf_va_arg_function, \%printf_info, \%PA_INT, \%PA_CHAR, \%PA_WCHAR,
\%PA_STRING, \%PA_WSTRING, \%PA_POINTER, \%PA_FLOAT, \%PA_DOUBLE, \%PA_LAST,
\%PA_FLAG_LONG_LONG, \%PA_FLAG_LONG_DOUBLE, \%PA_FLAG_LONG, \%PA_FLAG_SHORT,
\%PA_FLAG_PTR \- Definition von angepasstem Verhalten von printf\-artigen
Funktionen
.SH BIBLIOTHEK
Standard\-C\-Bibliothek (\fIlibc\fP,\ \fI\-lc\fP)
.SH ÜBERSICHT
.nf
\fB#include <printf.h>\fP
.P
\fBint register_printf_specifier(int \fP\fISpez\fP\fB, printf_function \fP\fIFunk\fP\fB,\fP
\fB                              printf_arginfo_size_function \fP\fIArginfo\fP\fB);\fP
\fBint register_printf_modifier(const wchar_t *\fP\fIZK\fP\fB);\fP
\fBint register_printf_type(printf_va_arg_function \fP\fIFkt\fP\fB);\fP
.fi
.SS Rückruffunktionen
.nf
\fBtypedef int printf_function(FILE *\fP\fIDatenstrom\fP\fB, const struct printf_info *\fP\fIInfo\fP\fB,\fP
\fB                              const void *const \fP\fIArg\fP\fB[]);\fP
\fBtypedef int printf_arginfo_size_function(const struct printf_info *\fP\fIInfo\fP\fB,\fP
\fB                              size_t \fP\fIn\fP\fB, int \fP\fIArgtypen\fP\fB[\fP\fIn\fP\fB], int \fP\fIGröße\fP\fB[\fP\fIn\fP\fB]);\fP
\fBtypedef void printf_va_arg_function(void *\fP\fISpeicher\fP\fB, va_list *\fP\fIaz\fP\fB);\fP
.fi
.SS Typen
.EX
\fBstruct printf_info {\fP
\fB    int            prec;            \fP// Genauigkeit
\fB    int            width;           \fP// Breite
\fB    wchar_t        spec;            \fP// Formatbuchstabe
\fB    unsigned int   is_long_double:1;\fP// Schalter \fBL\fP oder \fBll\fP
\fB    unsigned int   is_short:1;      \fP// Schalter \fBh\fP
\fB    unsigned int   is_long:1;       \fP// Schalter \fBl\fP
\fB    unsigned int   alt:1;           \fP// Schalter \fB#\fP
\fB    unsigned int   space:1;         \fP// Leerzeichenschalter
\fB    unsigned int   left:1;          \fP// Schalter \fB\-\fP
\fB    unsigned int   showsign:1;      \fP// Schalter \fB+\fP
\fB    unsigned int   group:1;         \fP// Schalter \fB\[aq]\fP
\fB    unsigned int   extra:1;         \fP// Zur besonderen Verwendung
\fB    unsigned int   is_char:1;       \fP// Schalter \fBhh\fP
\fB    unsigned int   wide:1;          \fP// Wahr bei Datenströmen mit weiten
\fB                                    \fP// Zeichen
\fB    unsigned int   i18n:1;          \fP// Schalter \fBI\fP
\fB    unsigned int   is_binary128:1;  \fP/* Fließkommaargument ist zu
\fB                                    \fP   IEC 60559 binary128 */
\fB                                    \fP   ABI\-kompatibel
\fB    unsigned short user;            \fP// Bits für Benutzer\-installierte
\fB                                    \fP// Modifikatoren
\fB    wchar_t        pad;             \fP// Auffüllzeichen
\fB};\fP
.EE
.SS Konstanten
.EX
\fB#define PA_FLAG_LONG_LONG    \fP/* … */
\fB#define PA_FLAG_LONG_DOUBLE  \fP/* … */
\fB#define PA_FLAG_LONG         \fP/* … */
\fB#define PA_FLAG_SHORT        \fP/* … */
\fB#define PA_FLAG_PTR          \fP/* … */
.EE
.SH BESCHREIBUNG
Diese Funktionen dienen dazu, das Verhalten der
\fBprintf\fP(3)\-Funktionsfamilie zu erweitern und/oder zu verändern.
.SS \fIregister_printf_specifier\fP()
Diese Funktion registriert einen angepassten Umwandlungskennzeichner für die
\fBprintf\fP(3)\-Funktionsfamilie.
.TP 
\fISpez\fP
Das Zeichen, das als Umwandlungskennzeichner in der Formatzeichenkette
verwandt werden wird.
.TP 
\fIFunk\fP
Rückruffunktion, die bei der Ausführung der \fBprintf\fP(3)\-Funktionsfamilie
ausgeführt wird, um die Eingabeargumente in die Ausgabeargumente
\fIDatenstrom\fP zu formatieren.
.RS
.TP 
\fIDatenstrom\fP
Ausgabedatenstrom, in den die formatierte Ausgabe geschrieben werden
soll. Dieser Datenstrom repräsentiert transparent die Ausgabe, selbst in
Fällen, in denen die Funktionen in eine Zeichenkette schreiben.
.TP 
\fIInfo\fP
Struktur, die Kontextinformationen hält, einschließlich der in der
Formatzeichenkette festgelegten Modifikatoren. Dies hält die gleichen
Inhalte wie in \fIArginfo\fP.
.TP 
\fIArg\fP
Feld von Zeigern auf Argumente der \fBprintf\fP(3)\-artigen Funktionen.
.RE
.TP 
\fIArginfo\fP
Rückruffunktion, die von der \fBprintf\fP(3)\-Funktionsfamilie ausgeführt wird,
um zu ermitteln, wie viele Argumente für die angepassten Kennzeichner
ausgewertet werden sollen und welchen Typ sie haben.
.RS
.TP 
\fIInfo\fP
Struktur, die Kontextinformationen hält, einschließlich der in der
Formatzeichenkette festgelegten Modifikatoren. Dies hält die gleichen
Inhalte wie \fIFunk\fP.
.TP 
\fIn\fP
Anzahl der noch auszuwertenden Argumente.
.TP 
\fIArgtypen\fP
Dieses Feld sollte gesetzt werden, um die Typen jedes ausgewerteten
Argumentes zu definieren. Jedes Element in der Liste repräsentiert eines der
auszuwertenden Argumente. Die Reihenfolge ist dabei identisch zu der
Reihenfolge, an der sie an die \fBprintf\fP(3)\-artige Funktion übergeben
werden. Jedes Element sollte auf einen Basistypen (\fBPA_\fP*) aus der
Aufzählung oben oder auf einen angepassten Typ gesetzt werden, und optional
mittels »OR« mit einem geeigneten Längenmodifikator (\fBPA_FLAG_\fP*) verknüpft
werden.
.RS
.P
Der Typ wird durch Verwendung einer der folgenden Konstanten bestimmt:
.TP 
\fBPA_INT\fP
\fIint\fP.
.TP 
\fBPA_CHAR\fP
\fIint\fP, typenumgewandelt zu \fIchar\fP.
.TP 
\fBPA_WCHAR\fP
\fIwchar_t\fP.
.TP 
\fBPA_STRING\fP
\fIconst char\ *\fP, eine »\[rs]0«\-begrenzte Zeichenkette.
.TP 
\fBPA_WSTRING\fP
\fIconst wchar_t\ *\fP, eine L\(aq\[rs]0\(aq\-begrenzte weite Zeichenkette.
.TP 
\fBPA_POINTER\fP
\fIvoid\ *\fP.
.TP 
\fBPA_FLOAT\fP
\fIfloat\fP.
.TP 
\fBPA_DOUBLE\fP
\fIdouble\fP.
.TP 
\fBPA_LAST\fP
OFFENE PUNKTE.
.RE
.TP 
\fIGröße\fP
Für benutzerdefinierte Typen sollte die Größe des Typs (in Byte) auch durch
dieses Feld festgelegt werden. Lassen Sie dies ansonsten unbenutzt.
.RE
.P
\fIArginfo\fP wird vor \fIFunk\fP aufgerufen und bereitet einige Informationen
vor, die zum Aufruf von \fIFunk\fP benötigt werden.
.SS \fIregister_printf_modifier\fP()
OFFENE PUNKTE
.SS \fIregister_printf_type\fP()
OFFENE PUNKTE
.SH RÜCKGABEWERT
\fB\%register_printf_specifier\fP(), \fB\%register_printf_modifier\fP() und
\fB\%register_printf_type\fP() liefern im Erfolgsfall Null zurück und \-1 bei
Fehler.
.SS Rückruffunktionen
Die Rückruffunktion vom Typ \fIprintf_function\fP sollte die Anzahl der
geschriebenen Zeichen zurückliefern oder \-1 bei Fehlern.
.P
Die Rückruffunktion vom Typ \fI\%printf_arginfo_size_function\fP sollte die
Anzahl der Argumente zurückliefern, die in diesem Kennzeichner ausgewertet
werden sollen. Sie gibt auch Informationen über den Typ dieser Argumente
über \fIArgtypen\fP an den Aufrufenden zurück. Im Fehlerfall sollte sie \-1
zurückliefern.
.SH FEHLER
.TP 
\fBEINVAL\fP
Der Kennzeichner war kein gültiges Zeichen.
.SH STANDARDS
GNU.
.SH GESCHICHTE
\fB\%register_printf_function\fP(3) ist eine ältere und als veraltet markierte
Funktion, ähnlich zu \fB\%register_printf_specifier\fP(). Diese Funktion kann
nicht mit benutzerdefinierten Typen umgehen.
.P
\fB\%register_printf_specifier\fP() ersetzt \fB\%register_printf_function\fP(3).
.SH BEISPIELE
Das folgende Beispielprogramm registriert die Kennzeichner »b« und »B« zum
Ausgeben von Ganzzahlen im Binärformat, was die Regeln für andere
vorzeichenfreie Umwandlungskennzeichner wie »x« und »u« spiegelt. Dies kann
vor C23 zur Ausgabe von Binärzahlen verwandt werden.
.P
.\" SRC BEGIN (register_printf_specifier.c)
.EX
/* Dieser Code ist gemeinfrei (»public domain«). */
\&
#include <err.h>
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
\&
#include <printf.h>
\&
#define GROUP_SEP  \[aq]\[rs]\[aq]\[aq]
\&
struct Printf_Pad {
    char    ch;
    size_t  len;
};
\&
static int b_printf(FILE *stream, const struct printf_info *info,
                    const void *const args[]);
static int b_arginf_sz(const struct printf_info *info,
                    size_t n, int argtypes[n], int size[n]);
\&
static uintmax_t b_value(const struct printf_info *info,
                    const void *arg);
static size_t b_bin_repr(char bin[UINTMAX_WIDTH],
                    const struct printf_info *info, const void *arg);
static size_t b_bin_len(const struct printf_info *info,
                    ptrdiff_t min_len);
static size_t b_pad_len(const struct printf_info *info,
                    ptrdiff_t bin_len);
static ssize_t b_print_prefix(FILE *stream,
                    const struct printf_info *info);
static ssize_t b_pad_zeros(FILE *stream, const struct printf_info *info,
                    ptrdiff_t min_len);
static ssize_t b_print_number(FILE *stream,
                    const struct printf_info *info,
                    const char bin[UINTMAX_WIDTH],
                    size_t min_len, size_t bin_len);
static char pad_ch(const struct printf_info *info);
static ssize_t pad_spaces(FILE *stream, size_t pad_len);
\&
int
main(void)
{
    if (register_printf_specifier(\[aq]b\[aq], b_printf, b_arginf_sz) == \-1)
        err(EXIT_FAILURE, "register_printf_specifier(\[aq]b\[aq], …)");
    if (register_printf_specifier(\[aq]B\[aq], b_printf, b_arginf_sz) == \-1)
        err(EXIT_FAILURE, "register_printf_specifier(\[aq]B\[aq], …)");
\&
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%llb;\[rs]n", 0x5Ellu);
    printf("%lB;\[rs]n", 0x5Elu);
    printf("%b;\[rs]n", 0x5Eu);
    printf("%hB;\[rs]n", 0x5Eu);
    printf("%hhb;\[rs]n", 0x5Eu);
    printf("%jb;\[rs]n", (uintmax_t)0x5E);
    printf("%zb;\[rs]n", (size_t)0x5E);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%#b;\[rs]n", 0x5Eu);
    printf("%#B;\[rs]n", 0x5Eu);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%10b;\[rs]n", 0x5Eu);
    printf("%010b;\[rs]n", 0x5Eu);
    printf("%.10b;\[rs]n", 0x5Eu);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%\-10B;\[rs]n", 0x5Eu);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%\[aq]B;\[rs]n", 0x5Eu);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%#16.12b;\[rs]n", 0xAB);
    printf("%\-#\[aq]20.12b;\[rs]n", 0xAB);
    printf("%#\[aq]020B;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%#020B;\[rs]n", 0xAB);
    printf("%\[aq]020B;\[rs]n", 0xAB);
    printf("%020B;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%#021B;\[rs]n", 0xAB);
    printf("%\[aq]021B;\[rs]n", 0xAB);
    printf("%021B;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%#022B;\[rs]n", 0xAB);
    printf("%\[aq]022B;\[rs]n", 0xAB);
    printf("%022B;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%#023B;\[rs]n", 0xAB);
    printf("%\[aq]023B;\[rs]n", 0xAB);
    printf("%023B;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%\-#\[aq]19.11b;\[rs]n", 0xAB);
    printf("%#\[aq]019B;\[rs]n", 0xAB);
    printf("%#019B;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
    printf("%\[aq]019B;\[rs]n", 0xAB);
    printf("%019B;\[rs]n", 0xAB);
    printf("%#016b;\[rs]n", 0xAB);
    printf("....\-\-\-\-....\-\-\-\-....\-\-\-\-....\-\-\-\-\[rs]n");
\&
    return 0;
}
\&
static int
b_printf(FILE *stream, const struct printf_info *info,
         const void *const args[])
{
    char               bin[UINTMAX_WIDTH];
    size_t             min_len, bin_len;
    ssize_t            len, tmp;
    struct Printf_Pad  pad = {0};
\&
    len = 0;
\&
    min_len = b_bin_repr(bin, info, args[0]);
    bin_len = b_bin_len(info, min_len);
\&
    pad.ch = pad_ch(info);
    if (pad.ch == \[aq] \[aq])
        pad.len = b_pad_len(info, bin_len);
\&
    /* Auffüllen mit \[aq] \[aq] (rechts ausgerichtet) */
    if ((pad.ch == \[aq] \[aq]) && !info\->left) {
        tmp = pad_spaces(stream, pad.len);
        if (tmp == EOF)
            return EOF;
        len += tmp;
    }
\&
    /* Präfix "0b"/"0B" */
    if (info\->alt) {
        tmp = b_print_prefix(stream, info);
        if (tmp == EOF)
            return EOF;
        len += tmp;
    }
\&
    /* Auffüllen mit \[aq]0\[aq] */
    if (pad.ch == \[aq]0\[aq]) {
        tmp = b_pad_zeros(stream, info, min_len);
        if (tmp == EOF)
            return EOF;
        len += tmp;
    }
\&
    /* Zahl ausgeben (einschließlich führender 0en, um die Genauigkeit aufzufüllen) */
    tmp = b_print_number(stream, info, bin, min_len, bin_len);
    if (tmp == EOF)
        return EOF;
    len += tmp;
\&
    /* Auffüllen mit \[aq] \[aq] (links ausgerichtet) */
    if (info\->left) {
        tmp = pad_spaces(stream, pad.len);
        if (tmp == EOF)
            return EOF;
        len += tmp;
    }
\&
    return len;
}
\&
static int
b_arginf_sz(const struct printf_info *info, size_t n, int argtypes[n],
            [[maybe_unused]] int size[n])
{
    if (n < 1)
        return \-1;
\&
    if (info\->is_long_double)
        argtypes[0] = PA_INT | PA_FLAG_LONG_LONG;
    else if (info\->is_long)
        argtypes[0] = PA_INT | PA_FLAG_LONG;
    else
        argtypes[0] = PA_INT;
\&
    return 1;
}
\&
static uintmax_t
b_value(const struct printf_info *info, const void *arg)
{
    if (info\->is_long_double)
        return *(const unsigned long long *)arg;
    if (info\->is_long)
        return *(const unsigned long *)arg;
\&
    /* short und char werden beide auf int aufgewertet */
    return *(const unsigned int *)arg;
}
\&
static size_t
b_bin_repr(char bin[UINTMAX_WIDTH],
           const struct printf_info *info, const void *arg)
{
    size_t     min_len;
    uintmax_t  val;
\&
    val = b_value(info, arg);
\&
    bin[0] = \[aq]0\[aq];
    for (min_len = 0; val; min_len++) {
        bin[min_len] = \[aq]0\[aq] + (val % 2);
        val >>= 1;
    }
\&
    return MAX(min_len, 1);
}
\&
static size_t
b_bin_len(const struct printf_info *info, ptrdiff_t min_len)
{
    return MAX(info\->prec, min_len);
}
\&
static size_t
b_pad_len(const struct printf_info *info, ptrdiff_t bin_len)
{
    ptrdiff_t  pad_len;
\&
    pad_len = info\->width \- bin_len;
    if (info\->alt)
        pad_len \-= 2;
    if (info\->group)
        pad_len \-= (bin_len \- 1) / 4;
\&
    return MAX(pad_len, 0);
}
\&
static ssize_t
b_print_prefix(FILE *stream, const struct printf_info *info)
{
    ssize_t len;
\&
    len = 0;
    if (fputc(\[aq]0\[aq], stream) == EOF)
        return EOF;
    len++;
    if (fputc(info\->spec, stream) == EOF)
        return EOF;
    len++;
\&
    return len;
}
\&
static ssize_t
b_pad_zeros(FILE *stream, const struct printf_info *info,
            ptrdiff_t min_len)
{
    ssize_t    len;
    ptrdiff_t  tmp;
\&
    len = 0;
    tmp = info\->width \- (info\->alt * 2);
    if (info\->group)
        tmp \-= tmp / 5 \- !(tmp % 5);
    for (ptrdiff_t i = tmp \- 1; i > min_len \- 1; i\-\-) {
        if (fputc(\[aq]0\[aq], stream) == EOF)
            return EOF;
        len++;
\&
        if (!info\->group || (i % 4))
            continue;
        if (fputc(GROUP_SEP, stream) == EOF)
            return EOF;
        len++;
    }
\&
    return len;
}
\&
static ssize_t
b_print_number(FILE *stream, const struct printf_info *info,
               const char bin[UINTMAX_WIDTH],
               size_t min_len, size_t bin_len)
{
    ssize_t  len;
\&
    len = 0;
\&
    /* Führende Nullen ausgeben, um die Genauigkeit aufzufüllen */
    for (size_t i = bin_len \- 1; i > min_len \- 1; i\-\-) {
        if (fputc(\[aq]0\[aq], stream) == EOF)
            return EOF;
        len++;
\&
        if (!info\->group || (i % 4))
            continue;
        if (fputc(GROUP_SEP, stream) == EOF)
            return EOF;
        len++;
    }
\&
    /* Zahl ausgeben */
    for (size_t i = min_len \- 1; i < min_len; i\-\-) {
        if (fputc(bin[i], stream) == EOF)
            return EOF;
        len++;
\&
        if (!info\->group || (i % 4) || !i)
            continue;
        if (fputc(GROUP_SEP, stream) == EOF)
            return EOF;
        len++;
    }
\&
    return len;
}
\&
static char
pad_ch(const struct printf_info *info)
{
    if ((info\->prec != \-1) || (info\->pad == \[aq] \[aq]) || info\->left)
        return \[aq] \[aq];
    return \[aq]0\[aq];
}
\&
static ssize_t
pad_spaces(FILE *stream, size_t pad_len)
{
    ssize_t  len;
\&
    len = 0;
    for (size_t i = pad_len \- 1; i < pad_len; i\-\-) {
        if (fputc(\[aq] \[aq], stream) == EOF)
            return EOF;
        len++;
    }
\&
    return len;
}
.EE
.\" SRC END
.SH "SIEHE AUCH"
\fBasprintf\fP(3), \fBprintf\fP(3), \fBwprintf\fP(3)
.PP
.SH ÜBERSETZUNG
Die deutsche Übersetzung dieser Handbuchseite wurde von
Helge Kreutzmann <debian@helgefjell.de>
erstellt.
.PP
Diese Übersetzung ist Freie Dokumentation; lesen Sie die
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License Version 3
.UE
oder neuer bezüglich der
Copyright-Bedingungen. Es wird KEINE HAFTUNG übernommen.
.PP
Wenn Sie Fehler in der Übersetzung dieser Handbuchseite finden,
schicken Sie bitte eine E-Mail an die
.MT debian-l10n-german@lists.debian.org
Mailingliste der Übersetzer
.ME .
