manpages-de - en to de translation catalogue (68 entries)

note: type: TH
en: 2019-03-06
de: 6. März 2019

note: type: TH
en: Linux Programmer's Manual
de: Linux-Programmierhandbuch

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: getopt, getopt_long, getopt_long_only, optarg, optind, opterr, optopt - Parse command-line options
de: getopt, getopt_long, getopt_long_only, optarg, optind, opterr, optopt - Befehlszeilenoptionen auswerten

note: type: SH
en: SYNOPSIS
de: ÜBERSICHT

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
de: Mit Glibc erforderliche Makros (siehe B<feature_test_macros>(7)):

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: The B<getopt>()  function parses the command-line arguments.  Its arguments I<argc> and I<argv> are the argument count and array as passed to the I<main>()  function on program invocation.  An element of I<argv> that starts with \(aq-\(aq (and is not exactly "-" or "--")  is an option element.  The characters of this element (aside from the initial \(aq-\(aq) are option characters.  If B<getopt>()  is called repeatedly, it returns successively each of the option characters from each of the option elements.
de: Die Funktion B<getopt>() wertet die Befehlszeilenoptionen aus. Ihre Argumente I<argc> und I<argv> sind die Argumentanzahl und das Argumentenfeld wie zur Funktion B<main>() bei Programmaufruf übergeben. Ein Element von I<argv>, das mit \(aq-\(aq beginnt (und nicht exakt »-« or »--«) ist, ist ein Optionselement. Die Zeichen dieses Elementes (ohne das einleitende \(aq-\(aq) sind Optionszeichen. Falls B<getopt>() wiederholt aufgerufen wird, gibt sie aufeinanderfolgend jedes der Optionszeichen von jedem Optionselement zurück.

note: type: Plain text
en: The variable I<optind> is the index of the next element to be processed in I<argv>.  The system initializes this value to 1.  The caller can reset it to 1 to restart scanning of the same I<argv>, or when scanning a new argument vector.
de: Die Variable I<optind> ist der Index des nächsten zu verarbeitenden Elements in I<argv>. Das System initialisiert diesen Wert mit 1. Der Aufrufende kann ihn auf 1 zurücksetzen, um das Durchsuchen des gleichen I<argv> erneut zu beginnen oder beim Durchsuchen eines neuen Argumentenfeldes.

note: type: Plain text
en: If B<getopt>()  finds another option character, it returns that character, updating the external variable I<optind> and a static variable I<nextchar> so that the next call to B<getopt>()  can resume the scan with the following option character or I<argv>-element.
de: Falls B<getopt>() ein weiteres Optionszeichen findet, gibt sie dieses Zeichen zurück, wobei die externe Variable I<optind> und eine statische Variable I<nextchar> auf neuen Stand gesetzt werden, so dass der nächste Aufruf von B<getopt>() die Suche mit dem folgenden Optionszeichen oder I<argv>-Element fortsetzen kann.

note: type: Plain text
en: If there are no more option characters, B<getopt>()  returns -1.  Then I<optind> is the index in I<argv> of the first I<argv>-element that is not an option.
de: Falls es keine weiteren Optionszeichen gibt, gibt B<getopt>() -1 zurück. Dann ist I<optind> der Index des ersten I<argv>-Elementes in I<argv>, das keine Option ist.

note: type: Plain text
en: I<optstring> is a string containing the legitimate option characters.  If such a character is followed by a colon, the option requires an argument, so B<getopt>()  places a pointer to the following text in the same I<argv>-element, or the text of the following I<argv>-element, in I<optarg>.  Two colons mean an option takes an optional arg; if there is text in the current I<argv>-element (i.e., in the same word as the option name itself, for example, "-oarg"), then it is returned in I<optarg>, otherwise I<optarg> is set to zero.  This is a GNU extension.  If I<optstring> contains B<W> followed by a semicolon, then B<-W foo> is treated as the long option B<--foo>.  (The B<-W> option is reserved by POSIX.2 for implementation extensions.)  This behavior is a GNU extension, not available with libraries before glibc 2.
de: I<optstring> ist eine Zeichenkette, die die gültigen Optionszeichen enthält. Falls solch ein Zeichen von einem Doppelpunkt gefolgt wird, benötigt diese Option ein Argument, weswegen B<getopt>() einen Zeiger auf den folgenden Text in dem selben I<argv>-Element oder den Text des folgenden I<argv>-Elementes in I<optarg> platziert. Zwei Doppelpunkte bedeuten, dass diese Option ein optionales Argument erwartet; falls es Text im aktuellen I<argv>-Element gibt, wird er in I<optarg> zurückgegeben, anderenfalls wird I<optarg> auf numerisch Null gesetzt. Dieses ist eine GNU-Erweiterung. Falls I<optstring> B<W> gefolgt von einem Semikolon enthält, wird B<-W foo> als lange Option B<--foo> interpretiert. (Die Option B<-W> ist von POSIX.2 für die Implementierung von Erweiterungen reserviert.) Dieses Verhalten ist eine GNU-Erweiterung, die nicht in Bibliotheken vor GNU Glibc 2 verfügbar war.

note: type: Plain text
en: By default, B<getopt>()  permutes the contents of I<argv> as it scans, so that eventually all the nonoptions are at the end.  Two other modes are also implemented.  If the first character of I<optstring> is \(aq+\(aq or the environment variable B<POSIXLY_CORRECT> is set, then option processing stops as soon as a nonoption argument is encountered.  If the first character of I<optstring> is \(aq-\(aq, then each nonoption I<argv>-element is handled as if it were the argument of an option with character code 1.  (This is used by programs that were written to expect options and other I<argv>-elements in any order and that care about the ordering of the two.)  The special argument "--" forces an end of option-scanning regardless of the scanning mode.
de: Standardmäßig vertauscht B<getopt>() den Inhalt von I<argv> beim Durchsuchen, so dass schließlich alle Nichtoptionen am Ende stehen. Zwei weitere Modi sind ebenfalls implementiert. Falls das erste Zeichen von I<optstring> ein \(aq+\(aq ist oder die Umgebungsvariable B<POSIXLY_CORRECT> gesetzt ist, dann stoppt die Optionsbearbeitung sobald ein Argument auftritt, das keine Option ist. Falls das erste Zeichen von I<optstring> ein \(aq-\(aq ist, dann wird jedes Argument von I<argv>, das keine Option ist, so behandelt, als ob es Argument einer Option mit dem Zeichencode 1 wäre. (Dies wird von Programmen benutzt, die Optionen und andere I<argv>-Elemente in beliebiger Reihenfolge erwarten, und die Wert auf die Reihenfolge der beiden legen.) Das besondere Argument »--« erzwingt die Beendigung der Suche nach Optionen unabhängig von der Suchmethode.

note: type: Plain text
en: While processing the option list, B<getopt>()  can detect two kinds of errors: (1) an option character that was not specified in I<optstring> and (2) a missing option argument (i.e., an option at the end of the command line without an expected argument).  Such errors are handled and reported as follows:
de: Beim Verarbeiten der Optionsliste kann B<getopt>() zwei Arten von Fehler erkennen: (1) ein Optionszeichen, das nicht in I<optstring> angegeben wurde und (2) ein fehlendes Optionsargument (d.h. eine Option am Ende der Befehlszeile ohne ein erwartetes Argument). Solche Fehler werden wie folgt verarbeitet und berichtet:

note: type: Plain text
en: By default, B<getopt>()  prints an error message on standard error, places the erroneous option character in I<optopt>, and returns \(aq?\(aq as the function result.
de: Standardmäßig gibt B<getopt>() eine Fehlermeldung auf der Standardfehlerausgabe aus, stellt das fehlerhafte Optionszeichen in I<optopt> und liefert »?« as Funktionsergebnis zurück.

note: type: Plain text
en: If the caller has set the global variable I<opterr> to zero, then B<getopt>()  does not print an error message.  The caller can determine that there was an error by testing whether the function return value is \(aq?\(aq.  (By default, I<opterr> has a nonzero value.)
de: Falls der Aufrufende die globale Variable I<opterr> auf Null gesetzt hat, dann gibt B<getopt>() keine Fehlermeldung aus. Der Aufrufende kann durch Testen, ob der Funktionsrückgabewert »?« ist, ermitteln, ob es einen Fehler gab. (Standardmäßig hat I<opterr> einen von Null verschiedenen Wert).

note: type: Plain text
en: If the first character (following any optional \(aq+\(aq or \(aq-\(aq described above)  of I<optstring> is a colon (\(aq:\(aq), then B<getopt>()  likewise does not print an error message.  In addition, it returns \(aq:\(aq instead of \(aq?\(aq to indicate a missing option argument.  This allows the caller to distinguish the two different types of errors.
de: Falls das erste Zeichen im I<optstring> (nach einem optionalen »+« oder »-« wie oben beschrieben) ein Doppelpunkt (»:«) ist, dann gibt B<getopt>() analog auch keine Fehlermeldung aus. Zusätzlich wird es »:« statt »?« zurückliefern, um ein fehlendes Argument anzuzeigen. Dies ermöglicht es dem Aufrufenden, die zwei Arten von Fehlern zu unterscheiden.

note: type: SS
en: getopt_long() and getopt_long_only()
de: getopt_long() und getopt_long_only()

note: type: Plain text
en: The B<getopt_long>()  function works like B<getopt>()  except that it also accepts long options, started with two dashes.  (If the program accepts only long options, then I<optstring> should be specified as an empty string (""), not NULL.)  Long option names may be abbreviated if the abbreviation is unique or is an exact match for some defined option.  A long option may take a parameter, of the form B<--arg=param> or B<--arg param>.
de: Die Funktion B<getopt_long>() arbeitet wie B<getopt>(), außer dass sie auch lange Optionsnamen unterstützt, die mit zwei Minuszeichen beginnen. (Falls das Programm nur lange Optionen unterstützt, dann sollte I<optstring> als leere Zeichenkette (»«) und nicht als NULL angegeben werden). Lange Optionsnamen dürfen abgekürzt werden, wenn die Abkürzung eindeutig ist oder genau einer definierten Option entspricht. Eine lange Option darf einen Parameter der Form B<--arg=param> oder B<--arg param> akzeptieren.

note: type: Plain text
en: I<longopts> is a pointer to the first element of an array of I<struct option> declared in I<E<lt>getopt.hE<gt>> as
de: I<longopts> ist ein Zeiger auf das erste Element eines Feldes von Strukturen B<struct option>, die in B<E<lt>getopt.hE<gt>> deklariert ist als

note: type: Plain text
en: The meanings of the different fields are:
de: Die Bedeutungen der einzelnen Felder sind:

note: type: Plain text
en: is the name of the long option.
de: ist der Name der langen Option.

note: type: Plain text
en: is: B<no_argument> (or 0) if the option does not take an argument; B<required_argument> (or 1) if the option requires an argument; or B<optional_argument> (or 2) if the option takes an optional argument.
de: ist: B<no_argument> (oder 0) falls die Option kein Argument erwartet, B<required_argument> (oder 1) falls die Option ein Argument benötigt oder B<optional_argument> (oder 2) falls die Option ein optionales Argument erwartet.

note: type: Plain text
en: specifies how results are returned for a long option.  If I<flag> is NULL, then B<getopt_long>()  returns I<val>.  (For example, the calling program may set I<val> to the equivalent short option character.)  Otherwise, B<getopt_long>()  returns 0, and I<flag> points to a variable which is set to I<val> if the option is found, but left unchanged if the option is not found.
de: gibt an, wie für eine lange Option Ergebnisse zurückgegeben werden. Falls I<flag> NULL ist, dann gibt B<getopt_long>() I<val> zurück. (Zum Beispiel kann das aufrufende Programm I<val> auf das Zeichen der äquivalenten Kurzoption setzen.) Anderenfalls gibt B<getopt_long>() 0 zurück und I<flag> zeigt auf eine Variable, die auf I<val> gesetzt wird, falls die Option gefunden wird, und die unverändert gelassen wird, falls die Option nicht gefunden wird.

note: type: Plain text
en: is the value to return, or to load into the variable pointed to by I<flag>.
de: ist der Wert, der zurückzugeben oder in die Variable zu laden ist, auf die I<flag> zeigt.

note: type: Plain text
en: The last element of the array has to be filled with zeros.
de: Das letzte Element des Feldes muss mit Nullen gefüllt werden.

note: type: Plain text
en: If I<longindex> is not NULL, it points to a variable which is set to the index of the long option relative to I<longopts>.
de: Falls I<longindex> nicht B<NULL> ist, zeigt er auf eine Variable, welche auf den Index der langen Option relativ zu I<longopts> gesetzt wird.

note: type: Plain text
en: B<getopt_long_only>()  is like B<getopt_long>(), but \(aq-\(aq as well as "--" can indicate a long option.  If an option that starts with \(aq-\(aq (not "--") doesn't match a long option, but does match a short option, it is parsed as a short option instead.
de: B<getopt_long_only>() ist wie B<getopt_long>(), jedoch kann \(aq-\(aq ebenso wie »--« eine lange Option anzeigen. Falls eine Option, die mit \(aq-\(aq anfängt (nicht »--«), zu keiner langen Option passt, jedoch zu einer kurzen Option, so wird sie wie eine kurze Option behandelt.

note: type: SH
en: RETURN VALUE
de: RÜCKGABEWERT

note: type: Plain text
en: If an option was successfully found, then B<getopt>()  returns the option character.  If all command-line options have been parsed, then B<getopt>()  returns -1.  If B<getopt>()  encounters an option character that was not in I<optstring>, then \(aq?\(aq is returned.  If B<getopt>()  encounters an option with a missing argument, then the return value depends on the first character in I<optstring>: if it is \(aq:\(aq, then \(aq:\(aq is returned; otherwise \(aq?\(aq is returned.
de: Falls eine Option erfolgreich gefunden wurde, gibt B<getopt>() das Optionszeichen zurück. Falls alle Befehlszeilenargumente erfolgreich ausgewertet wurden, gibt B<getopt>() -1 zurück. Falls B<getopt>() ein Optionszeichen antrifft, das nicht in I<optstring> enthalten war, wird \(aq?\(aq zurückgegeben. Falls B<getopt>() auf eine Option trifft, der ein Argument fehlt, hängt der Rückgabewert vom ersten Zeichen in I<optstring> ab: Falls es ein \(aq:\(aq ist, wird \(aq:\(aq zurückgegeben; anderenfalls \(aq?\(aq.

note: type: Plain text
en: B<getopt_long>()  and B<getopt_long_only>()  also return the option character when a short option is recognized.  For a long option, they return I<val> if I<flag> is NULL, and 0 otherwise.  Error and -1 returns are the same as for B<getopt>(), plus \(aq?\(aq for an ambiguous match or an extraneous parameter.
de: B<getopt_long>() und B<getopt_long_only>() geben auch das Optionszeichen zurück, wenn eine kurze Option gefunden wurde. Für eine lange Option geben sie I<val> zurück, wenn I<flag> B<NULL> ist, anderenfalls 0. Fehler- und -1-Rückgaben sind wie bei B<getopt>(), zusätzlich jedoch \(aq-\(aq für eine unzureichende Übereinstimmung oder einen überzähligen Parameter.

note: type: SH
en: ENVIRONMENT
de: UMGEBUNGSVARIABLEN

note: type: Plain text
en: If this is set, then option processing stops as soon as a nonoption argument is encountered.
de: Falls sie gesetzt ist, dann stoppt die Optionsbearbeitung, sobald ein Argument auftritt, das keine Option ist.

note: type: Plain text
en: This variable was used by B<bash>(1)  2.0 to communicate to glibc which arguments are the results of wildcard expansion and so should not be considered as options.  This behavior was removed in B<bash>(1)  version 2.01, but the support remains in glibc.
de: Diese Variable wurde von der B<bash>(1)-Version 2.0 genutzt, um der Glibc mitzuteilen, welche Argumente Ergebnis der Ersetzung von Platzhaltern und somit nicht als Optionen anzusehen sind. Dieses Verhalten wurde in der B<bash>(1)-Version 2.01 entfernt, wird aber weiterhin von der Glibc unterstützt.

note: type: SH
en: ATTRIBUTES
de: ATTRIBUTE

note: type: Plain text
en: For an explanation of the terms used in this section, see B<attributes>(7).
de: Siehe B<attributes>(7) für eine Erläuterung der in diesem Abschnitt verwandten Ausdrücke.

note: type: tbl table
en: Interface
de: Schnittstelle

note: type: tbl table
en: Attribute
de: Attribut

note: type: tbl table
en: Value
de: Wert

note: type: tbl table
en: Thread safety
de: Multithread-Fähigkeit

note: type: SH
en: CONFORMING TO
de: KONFORM ZU

note: type: Plain text
en: POSIX.1-2001, POSIX.1-2008, and POSIX.2, provided the environment variable B<POSIXLY_CORRECT> is set.  Otherwise, the elements of I<argv> aren't really I<const>, because we permute them.  We pretend they're I<const> in the prototype to be compatible with other systems.
de: POSIX.1-2001, POSIX.1-2008 und POSIX.2, vorausgesetzt, die Umgebungsvariable POSIXLY_CORRECT ist gesetzt. Anderenfalls sind die Elemente von I<argv> nicht wirklich I<const>, da wir sie vertauschen. Wir geben im Prototypen vor, sie seien I<const>, um kompatibel zu anderen Systemen zu sein.

note: type: Plain text
en: The use of \(aq+\(aq and \(aq-\(aq in I<optstring> is a GNU extension.
de: Die Verwendung von \(aq+\(aq und \(aq-\(aq in I<optstring> ist eine GNU-Erweiterung.

note: type: Plain text
en: On some older implementations, B<getopt>()  was declared in I<E<lt>stdio.hE<gt>>.  SUSv1 permitted the declaration to appear in either I<E<lt>unistd.hE<gt>> or I<E<lt>stdio.hE<gt>>.  POSIX.1-1996 marked the use of I<E<lt>stdio.hE<gt>> for this purpose as LEGACY.  POSIX.1-2001 does not require the declaration to appear in I<E<lt>stdio.hE<gt>>.
de: In einigen älteren Implementierungen wurde B<getopt>() in I<E<lt>stdio.hE<gt>> deklariert. SUSv1 gestattete die Deklaration entweder in I<E<lt>unistd.hE<gt>> oder I<E<lt>stdio.hE<gt>>. POSIX.1-1995 kennzeichnete die Verwendung von I<E<lt>stdio.hE<gt>> zu diesem Zweck als LEGACY. POSIX.1-2001 verlangt nicht, dass diese Deklaration in I<E<lt>stdio.hE<gt>> enthalten ist.

note: type: TP
en: B<getopt_long>() and B<getopt_long_only>():
de: B<getopt_long>() und B<getopt_long_only>():

note: type: Plain text
en: These functions are GNU extensions.
de: Diese Funktionen sind GNU-Erweiterungen.

note: type: SH
en: NOTES
de: ANMERKUNGEN

note: type: Plain text
en: A program that scans multiple argument vectors, or rescans the same vector more than once, and wants to make use of GNU extensions such as \(aq+\(aq and \(aq-\(aq at the start of I<optstring>, or changes the value of B<POSIXLY_CORRECT> between scans, must reinitialize B<getopt>()  by resetting I<optind> to 0, rather than the traditional value of 1.  (Resetting to 0 forces the invocation of an internal initialization routine that rechecks B<POSIXLY_CORRECT> and checks for GNU extensions in I<optstring>.)
de: Ein Programm, das mehrere Argumentvektoren oder denselben Argumentvektor mehrfach auswertet und GNU-Erweiterungen wie beispielsweise \(aq+\(aq und \(aq-\(aq am Anfang von I<optstring> nutzen möchte oder zwischen den Auswertungen den Wert von B<POSIXLY_CORRECT> ändert, muss B<getopt>() neu initialisieren, indem es I<optind> auf 0 statt des traditionellen Wertes 1 setzt. (Das Rücksetzen auf 0 erzwingt den Aufruf einer internen Initialisierungsroutine, die erneut B<POSIXLY_CORRECT> prüft und in I<optstring> nach GNU-Erweiterungen sucht.)

note: type: SH
en: EXAMPLE
de: BEISPIEL

note: type: Plain text
en: The following trivial example program uses B<getopt>()  to handle two program options: I<-n>, with no associated value; and I<-t val>, which expects an associated value.
de: Das folgende triviale Beispielprogramm verwendet B<getopt>(), um zwei Programmoptionen zu verarbeiten: I<-n> ohne zugehörigen Wert und I<-t Wert>, die einen zugehörigen Wert erwartet.

note: type: Plain text
en:     nsecs = 0;
        tfnd = 0;
        flags = 0;
        while ((opt = getopt(argc, argv, "nt:")) != -1) {
            switch (opt) {
            case \(aqn\(aq:
                flags = 1;
                break;
            case \(aqt\(aq:
                nsecs = atoi(optarg);
                tfnd = 1;
                break;
            default: /* \(aq?\(aq */
                fprintf(stderr, "Usage: %s [-t nsecs] [-n] name\en",
                        argv[0]);
                exit(EXIT_FAILURE);
            }
        }
de:     nsecs = 0;
        tfnd = 0;
        flags = 0;
        while ((opt = getopt(argc, argv, "nt:")) != -1) {
            switch (opt) {
            case \(aqn\(aq:
                flags = 1;
                break;
            case \(aqt\(aq:
                nsecs = atoi(optarg);
                tfnd = 1;
                break;
            default: /* \(aq?\(aq */
                fprintf(stderr, "Verwendung: %s [-t nsecs] [-n] Name\en",
                        argv[0]);
                exit(EXIT_FAILURE);
            }
        }

note: type: Plain text
en:     if (optind E<gt>= argc) {
            fprintf(stderr, "Expected argument after options\en");
            exit(EXIT_FAILURE);
        }
de:     if (optind E<gt>= argc) {
            fprintf(stderr,
                    "Nach den Optionen wurde ein Argument erwartet\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Other code omitted */
de:     /* Weiterer Code weggelassen */

note: type: Plain text
en: The following example program illustrates the use of B<getopt_long>()  with most of its features.
de: Das folgende Beispielprogramm veranschaulicht die Benutzung von B<getopt_long>() mit der Mehrzahl ihrer Funktionalitäten.

note: type: Plain text
en: #include E<lt>stdio.hE<gt>     /* for printf */
    #include E<lt>stdlib.hE<gt>    /* for exit */
    #include E<lt>getopt.hE<gt>
de: #include E<lt>stdio.hE<gt>     /* für printf */
    #include E<lt>stdlib.hE<gt>    /* für exit */
    #include E<lt>getopt.hE<gt>

note: type: Plain text
en:         switch (c) {
            case 0:
                printf("option %s", long_options[option_index].name);
                if (optarg)
                    printf(" with arg %s", optarg);
                printf("\en");
                break;
de:       switch (c)
            {
            case 0:
              printf ("Option %s", long_options[option_index].name);
              if (optarg)
                printf (" mit Argument %s", optarg);
              printf ("\en");
              break;

note: type: Plain text
en:         case \(aq0\(aq:
            case \(aq1\(aq:
            case \(aq2\(aq:
                if (digit_optind != 0 && digit_optind != this_option_optind)
                  printf("digits occur in two different argv-elements.\en");
                digit_optind = this_option_optind;
                printf("option %c\en", c);
                break;
de:         case '0':
            case '1':
            case '2':
              if (digit_optind != 0 && digit_optind != this_option_optind)
                printf (
                  "Zahlen in zwei verschiedenen argv-Elementen gefunden.\en");
              digit_optind = this_option_optind;
              printf ("Option %c\en", c);
              break;

note: type: Plain text
en:         case \(aqa\(aq:
                printf("option a\en");
                break;
de:         case \(aqa\(aq:
                printf("Option a\en");
                break;

note: type: Plain text
en:         case \(aqb\(aq:
                printf("option b\en");
                break;
de:         case \(aqb\(aq:
                printf("Option b\en");
                break;

note: type: Plain text
en:         case \(aqc\(aq:
                printf("option c with value \(aq%s\(aq\en", optarg);
                break;
de:         case \(aqc\(aq:
                printf("Option c mit Wert \(aq%s\(aq\en", optarg);
                break;

note: type: Plain text
en:         case \(aqd\(aq:
                printf("option d with value \(aq%s\(aq\en", optarg);
                break;
de:         case \(aqd\(aq:
                printf("Option d mit Wert \(aq%s\(aq\en", optarg);
                break;

note: type: Plain text
en:         default:
                printf("?? getopt returned character code 0%o ??\en", c);
            }
        }
de:         default:
              printf ("?? getopt lieferte Zeichencode 0%o zurück ??\en", c);
            }
        }

note: type: Plain text
en:     if (optind E<lt> argc) {
            printf("non-option ARGV-elements: ");
            while (optind E<lt> argc)
                printf("%s ", argv[optind++]);
            printf("\en");
        }
de:   if (optind E<lt> argc) {
          printf ("Nichtoptionselemente von ARGV: ");
          while (optind E<lt> argc)
              printf ("%s ", argv[optind++]);
          printf ("\en");
        }

note: type: SH
en: SEE ALSO
de: SIEHE AUCH

note: type: SH
en: COLOPHON
de: KOLOPHON

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
