gcc 4.6.1 - en to de translation catalogue (8108 entries)

en: 
    For bug reporting instructions, please see:
de: 
    Zum Einsenden von Fehlerberichten (auf Englisch) lesen Sie bitte die
    folgenden Hinweise; Fehler in der deutschen Übersetzung sind an
    translation-team-de@lists.sourceforge.net zu melden:

en: 
    For bug reporting instructions, please see:
    %s.
de: 
    Zum Einsenden von Fehlerberichten (auf Englisch) lesen Sie bitte die Hinweise in:
    %s.
    Fehler in der deutschen Übersetzung sind an translation-team-de@lists.sourceforge.net zu melden.

en: 
    Go ahead? (y or n)
de: 
    Fortfahren? (y oder n)

en: 
    Linker options
    ==============
de: 
    Linkeroptionen
    ==============

en: 
    Options starting with -g, -f, -m, -O, -W, or --param are automatically
     passed on to the various sub-processes invoked by %s.  In order to pass
     other options on to these processes the -W<letter> options must be used.
de: 
    Optionen, die mit -g, -f, -m, -O, -W, oder --param beginnen, werden automatisch
     an die verschiedenen Subprozesse, die von %s aufgerufen werden, übergeben.
     Um andere Optionen an diese Prozesse zu übergeben, müssen die Optionen
     -W<Buchstabe> verwendet werden.

en: 
    ldd output with constructors/destructors.
de: 
    Ausgabe von ldd mit Konstruktoren/Destruktoren.

en: 
    write_c_file - output name is %s, prefix is %s
de: 
    write_c_file - Ausgabename ist %s, Präfix ist %s

en:                            Display specific types of command line options
de:                            Spezifische Typen der Kommandozeilenoptionen anzeigen

en:         <anonymous>
de:         <anonym>

en:     Included at %s:%d:
de:     Eingefügt bei %s:%d:

en:     inlined from %qs
de:     eingefügt von %qs

en:     inlined from %qs at %s:%d
de:     eingefügt von %qs bei %s:%d

en:     inlined from %qs at %s:%d:%d
de:     eingefügt von %qs bei %s:%d:%d

en:    by earlier handler for %<%T%>
de:    von früherem Behandler für %<%T%>

en:    by earlier handler for %qT
de:    von früherem Behandler für %qT

en:    in pointer to member conversion
de:    in Umwandlung in Zeiger auf Element

en:    in pointer to member function conversion
de:    in Umwandlung in Zeiger auf Elementfunktion

en:   %q+#D declared here
de:   %q+#D hier deklariert

en:   (Use '-v --help' to display command line options of sub-processes)
de:   ('-v --help' zum Anzeigen der Kommandozeilenoptionen von Subprozessen verwenden)

en:   (you can disable this with -fno-deduce-init-list)
de:   (dies kann mit -fno-deduce-init-list abgeschaltet werden)

en:   -###                     Like -v but options quoted and commands not executed
de:   -###                     Wie -v, aber mit zitierten Optionen und nicht
                               ausgeführten Befehlen

en:   --bootclasspath PATH    Override built-in class path
de:   --bootclasspath PFAD    Eingebauten Klassenpfad ersetzen

en:   --classpath PATH        Set path to find .class files
de:   --classpath PFAD        Pfad zum Finden von .class-Dateien setzen

en:   --extdirs PATH          Set extensions directory path
de:   --extdirs PFAD          Pfad für Erweiterungen setzen

en:   --help                   Display this information
de:   --help                   Diese Informationen anzeigen

en:   --help                  Print this help, then exit
de:   --help                  Diese Hilfe anzeigen und beenden

en:   --javap                 Generate output in 'javap' format
de:   --javap                 Ausgabe im »javap«-Format erzeugen

en:   --sysroot=<directory>    Use <directory> as the root directory for headers
                               and libraries
de:   --sysroot=<Verzeichnis>  <Verzeichnis> als Root-Verzeichnis für Header und
                               Bibliotheken verwenden

en:   --target-help            Display target specific command line options
de:   --target-help            Zielspezifische Kommandozeilenoptionen anzeigen

en:   --version                Display compiler version information
de:   --version                Compilerversionsinformation anzeigen

en:   --version               Print version number, then exit
de:   --version               Versionsnummer anzeigen und beenden

en:   -B <directory>           Add <directory> to the compiler's search paths
de:   -B <Verzeichnis>         <Verzeichnis> zum Suchpfad des Compilers hinzufügen

en:   -E                       Preprocess only; do not compile, assemble or link
de:   -E                       Nur Präprozessor, kein Compiler, Assembler oder
                               Binder

en:   -IDIR                   Append directory to class path
de:   -IDIR                   Verzeichnis an Klassenpfad anhängen

en:   -S                       Compile only; do not assemble or link
de:   -S                       Nur kompilieren, nicht assemblieren oder binden

en:   -Wa,<options>            Pass comma-separated <options> on to the assembler
de:   -Wa,<Optionen>           Komma-getrennte <Optionen> an Assembler übergeben

en:   -Wl,<options>            Pass comma-separated <options> on to the linker
de:   -Wl,<Optionen>           Komma-getrennte <Optionen> an Linker übergeben

en:   -Wp,<options>            Pass comma-separated <options> on to the preprocessor
de:   -Wp,<Optionen>           Komma-getrennte <Optionen> an Präprozessor übergeben

en:   -Xassembler <arg>        Pass <arg> on to the assembler
de:   -Xassembler <arg>        <arg> an den Assembler übergeben

en:   -Xlinker <arg>           Pass <arg> on to the linker
de:   -Xlinker <arg>           <arg> an den Linker übergeben

en:   -Xpreprocessor <arg>     Pass <arg> on to the preprocessor
de:   -Xpreprocessor <arg>     <arg> an den Präprozessor übergeben

en:   -a, --all-blocks                Show information for every basic block
de:   -a, --all-blocks                Informationen für jeden Basisblock zeigen

en:   -b, --branch-probabilities      Include branch probabilities in output
de:   -b, --branch-probabilities      Zweigwahrscheinlichkeiten in Ausgabe aufnehmen

en:   -c                       Compile and assemble, but do not link
de:   -c                       Nur kompilieren und assemblieren, aber nicht binden

en:   -c                      Disassemble method bodies
de:   -c                      Methodenkörper disassemblieren

en:   -c, --branch-counts             Given counts of branches taken
                                        rather than percentages
de:   -c, --branch-counts             Angegebene Zweigzahlen statt Anteilen nehmen

en:   -d, --display-progress          Display progress information
de:   -d, --display-progress          Fortschrittsinformationen anzeigen

en:   -dumpmachine             Display the compiler's target processor
de:   -dumpmachine             Zielprozessor des Compilers anzeigen

en:   -dumpspecs               Display all of the built in spec strings
de:   -dumpspecs               Alle eingebauten Spezifikationszeichenketten anzeigen

en:   -dumpversion             Display the version of the compiler
de:   -dumpversion             Compilerversion anzeigen

en:   -f, --function-summaries        Output summaries for each function
de:   -f, --function-summaries        Ausgabezusammenfassungen für jede Funktion

en:   -h, --help                      Print this help, then exit
de:   -h, --help                      Diese Hilfe anzeigen

en:   -l, --long-file-names           Use long output file names for included
                                        source files
de:   -l, --long-file-names           Lange Dateinamen für Ausgabedateien für
                                        eingefügte Quelldateien verwenden

en:   -n, --no-output                 Do not create an output file
de:   -n, --no-output                 Keine Ausgabedatei erzeugen

en:   -no-canonical-prefixes   Do not canonicalize paths when building relative
                               prefixes to other gcc components
de:   -no-canonical-prefixes   Pfade beim Erzeugen relativer Präfixe zu anderen
                               GCC-Komponenten nicht kanonisieren

en:   -o <file>                Place the output into <file>
de:   -o <Datei>               Ausgabe in <Datei> schreiben

en:   -o FILE                 Set output file name
de:   -o DATEI                Ausgabedateinamen setzen

en:   -o, --object-directory DIR|FILE Search for object files in DIR or called FILE
de:   -o, --object-directory DIR|FILE In DIR oder aufgerufener Datei FILE nach
                                      Objektdateien suchen

en:   -p, --preserve-paths            Preserve all pathname components
de:   -p, --preserve-paths            Alle Pfadnamenskomponenten bewahren

en:   -pass-exit-codes         Exit with highest error code from a phase
de:   -pass-exit-codes         Ende mit höchstem Rückgabe-Code einer Phase

en:   -pipe                    Use pipes rather than intermediate files
de:   -pipe                    Pipes statt temporärer Dateien verwenden

en:   -print-file-name=<lib>   Display the full path to library <lib>
de:   -print-file-name=<lib>   Vollen Pfad zur Bibliothek <lib> anzeigen

en:   -print-libgcc-file-name  Display the name of the compiler's companion library
de:   -print-libgcc-file-name  Name der Begleitbibliothek des Compilers anzeigen

en:   -print-multi-directory   Display the root directory for versions of libgcc
de:   -print-multi-directory   Wurzelverzeichnis für Versionen von libgcc anzeigen

en:   -print-multi-lib         Display the mapping between command line options and
                               multiple library search directories
de:   -print-multi-lib         Abbildung zwischen Kommandozeilenoptionen und
                               mehreren Suchverzeichnissen für Bibliotheken anzeigen

en:   -print-multi-os-directory Display the relative path to OS libraries
de:   -print-multi-os-directory Relativen Pfad zu Betriebssystembibliotheken
                                anzeigen

en:   -print-prog-name=<prog>  Display the full path to compiler component <prog>
de:   -print-prog-name=<prog>  Vollen Pfad zur Compilerkomponente <prog> anzeigen

en:   -print-search-dirs       Display the directories in the compiler's search path
de:   -print-search-dirs       Verzeichnisse im Suchpfad des Compilers anzeigen

en:   -print-sysroot           Display the target libraries directory
de:   -print-sysroot           Verzeichnis der Ziel-Bibliotheken anzeigen

en:   -print-sysroot-headers-suffix Display the sysroot suffix used to find headers
de:   -print-sysroot-headers-suffix Den für Headersuche verwendeten sysroot-Suffix anzeigen

en:   -save-temps              Do not delete intermediate files
de:   -save-temps              Temporäre Dateien nicht löschen

en:   -save-temps=<arg>        Do not delete intermediate files
de:   -save-temps=<arg>        Temporäre Dateien nicht löschen

en:   -specs=<file>            Override built-in specs with the contents of <file>
de:   -specs=<Datei>           Eingebaute Spezifikationen mit Inhalt der <Datei>
                               überschreiben

en:   -std=<standard>          Assume that the input sources are for <standard>
de:   -std=<Standard>          Annehmen, dass die Eingabequellen für <Standard> sind

en:   -time                    Time the execution of each subprocess
de:   -time                    Zeit für Ausführung jedes Subprozesses stoppen

en:   -u, --unconditional-branches    Show unconditional branch counts too
de:   -u, --unconditional-branches    Auch unbedingte Zweigzähler zeigen

en:   -v                       Display the programs invoked by the compiler
de:   -v                       Vom Compiler aufgerufene Programme anzeigen

en:   -v, --verbose           Print extra information while running
de:   -v, --verbose           Zusatzinformationen beim Betrieb anzeigen

en:   -v, --version                   Print version number, then exit
de:   -v, --version                   Versionsnummer anzeigen

en:   -x <language>            Specify the language of the following input files
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behavior of
                               guessing the language based on the file's extension
de:   -x <Sprache>             Sprache der folgenden Eingabedateien angeben
                               Zulässige Sprachen sind: c c++ assembler none
                               'none' bedeutet den Rückfall auf das Standard-
                               verhalten, die Sprache aufgrund der Dateinamens-
                               erweiterung zu vermuten

en:   a qualified-id is required
de:   eine qualifizierte ID ist erforderlich

en:   as it is a non-system directory that duplicates a system directory
de:   da es ein Nicht-Systemverzeichnis ist, das ein Systemverzeichnis dupliziert

en:   base %qT
de:   Basis %qT

en:   because conversion sequence for the argument is better
de:   denn die Umwandlungsfolge für das Argument ist besser

en:   because of local member %q+#D with same name
de:   wegen lokalem Element %q+#D mit gleichem Namen

en:   because of local method %q+#D with same name
de:   wegen lokaler Methode %q+#D mit gleichem Namen

en:   because the following virtual functions are pure within %qT:
de:   denn die folgenden virtuellen Funktionen sind rein innerhalb %qT:

en:   but %d required
de:   aber %d benötigt

en:   but does not override %<%T(const %T&)%>
de:   aber überschreibt nicht %<%T(const %T&)%>

en:   but does not override %<operator=(const %T&)%>
de:   aber überschreibt nicht %<operator=(const %T&)%>

en:   by %q+D
de:   von %q+D

en:   candidate conversions include %qD and %qD
de:   in Frage kommende Umwandlungen beziehen %qD und %qD ein

en:   candidate expects %d argument, %d provided |   candidate expects %d arguments, %d provided
de[0]:   Kandidat erwartet %d Argument, %d angegeben
de[1]:   Kandidat erwartet %d Argumente, %d angegeben

en:   cannot use obsolete binding at %q+D because it has a destructor
de:   veraltete Bindung bei %q+D kann nicht verwendet werden, weil es einen Destruktor hat

en:   crosses initialization of %q+#D
de:   überschneidet Initialisierung von %q+#D

en:   enters OpenMP structured block
de:   tritt in OpenMP-strukturierten Block ein

en:   enters catch block
de:   tritt in catch-Block ein

en:   enters scope of %q+#D which has non-trivial destructor
de:   Eintritt in Gültigkeitsbereich von %q+#D mit nicht-trivialem Destruktor

en:   enters try block
de:   tritt in try-Block ein

en:   exits OpenMP structured block
de:   beendet OpenMP-strukturierten Block

en:   expected a class template, got %qE
de:   Klassentemplate erwartet, %qE erhalten

en:   expected a class template, got %qT
de:   Klassentemplate erwartet, %qT erhalten

en:   expected a constant of type %qT, got %qT
de:   Konstante des Typs %qT erwartet, %qT erhalten

en:   expected a template of type %qD, got %qT
de:   ein Template des Typs %qD erwartet, %qT erhalten

en:   expected a type, got %qE
de:   einen Typ erwartet, %qE erhalten

en:   expected a type, got %qT
de:   einen Typ erwartet, %qT erhalten

en:   for a function-style cast, remove the redundant %<::%D%>
de:   für Umwandlung im Funktions-Stil muss das überflüssige %<::%D%> entfernt werden

en:   for conversion from %qT to %qT
de:   für Umwandlung von %qT in %qT

en:   from definition of %q+#D
de:   aus Definition von %q+#D

en:   from here
de:   von hier

en:   in call to %q+D
de:   in Aufruf von %q+D

en:   in call to %qD
de:   in Aufruf von %qD

en:   in evaluation of %<%Q(%#T, %#T)%>
de:   in Auswertung von %<%Q(%#T, %#T)%>

en:   in instantiation of template %qT
de:   in Instanziierung des Templates %qT

en:   in thrown expression
de:   in geworfenem Ausdruck

en:   initializing argument %P of %q+D
de:   Argument %P von %q+D wird initialisiert

en:   initializing argument %P of %qD
de:   Argument %P von %qD wird initialisiert

en:   matches this %q+D under ISO standard rules
de:   passt nach ISO-Standardregeln zu diesem %q+D

en:   matches this %q+D under old rules
de:   passt nach den alten Regeln zu diesem %q+D

en:   no known conversion for argument %d from %qT to %qT
de:   keine bekannte Umwandlung für Argument %d von %qT nach %qT

en:   no known conversion for implicit %<this%> parameter from %qT to %qT
de:   keine bekannte Umwandlung für impliziten %<this%>-Parameter von %qT nach %qT

en:   or %<operator=(const %T&)%>
de:   oder %<operator=(const %T&)%>

en:   overriding %q+#D
de:   %q+#D wird überschrieben

en:   overriding %q+#F
de:   %q+#F wird überschrieben

en:   profiling support are only provided in archive format
de:   Profiling-Unterstützung nur im Archivformat unterstützt werden

en:   since %q+#D declared in base class
de:   denn %q+#D ist in Basisklasse deklariert

en:   since type %qT has pure virtual functions
de:   denn der Typ %qT hat rein virtuelle Funktionen

en:   skips initialization of %q+#D
de:   überspringt Initialisierung von %q+#D

en:   trying to instantiate %qD
de:   Versuch, %qD zu instanziieren

en:   using obsolete binding at %q+D
de:   bei %q+D wird veraltete Bindung verwendet

en:   when initialized here
de:   während es hier initialisiert wurde

en:   you can work around this by removing the initializer
de:   dies kann durch das Löschen der Initialisierung umgangen werden

en:  All options with the desired characteristics have already been displayed
de:  Alle Optionen mit den gewünschten Eigenschaften wurden bereits angezeigt

en:  No options with the desired characteristics were found
de:  Keine Optionen mit den gewünschten Eigenschaften gefunden

en:  candidate 1: %q+#F
de:  Kandidat 1: %q+#F

en:  candidate 2: %q+#F
de:  Kandidat 2: %q+#F

en:  conflicting code gen style switches are used
de:  in Konflikt stehende Codeerzeugungsschalter verwendet

en:  shadows template parm %q+#D
de:  überdeckt Templateparameter %q+#D

en: ! It would be better to auto-generate this file.
de: ! Es wäre besser, diese Datei automatisch erzeugen zu lassen.

en: !$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L
de: Eingebaute Zuweisung !$OMP ATOMIC IAND, IOR oder IEOR muss bei %L zwei Argumente haben

en: !$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L
de: Eingebaute Zuweisung !$OMP ATOMIC muss bei %L MIN, MAX, IAND, IOR oder IEOR sein

en: !$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L
de: Zuweisung !$OMP ATOMIC muss bei %L »var = var op expr« oder »var = expr op var« sein

en: !$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L
de: !$OMP ATOMIC Zuweisung muss auf der rechten Seite bei %L Operator oder Intrinsic haben

en: !$OMP ATOMIC assignment operator must be +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L
de: Zuweisungsoperator !$OMP ATOMIC muss bei %L +, *, -, /, .AND., .OR., .EQV. oder .NEQV. sein

en: !$OMP ATOMIC intrinsic arguments except one must not reference '%s' at %L
de: !$OMP ATOMIC intrinsische Argumente außer einem dürfen bei %2$L nicht »%1$s« referenzieren

en: !$OMP ATOMIC intrinsic arguments must be scalar at %L
de: !$OMP ATOMIC intrinsische Argumente müssen bei %L skalar sein

en: !$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L
de: Anweisung !$OMP ATOMIC muss eine skalare Variable intrinsischen Typs bei %L setzen

en: !$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L
de: !$OMP ATOMIC »var op expr« bei %L ist nicht mathematisch äquivalent mit »var = var op (expr)«

en: !$OMP DO cannot be a DO WHILE or DO without loop control at %L
de: !$OMP DO kann bei %L kein DO WHILE oder DO ohne Schleifensteuerung sein

en: !$OMP DO iteration variable must be of type integer at %L
de: !$OMP DO-Schleifenvariable muss bei %L ganzzahligen Typs sein

en: !$OMP DO iteration variable must not be THREADPRIVATE at %L
de: !$OMP DO-Schleifenvariable darf bei %L nicht THREADPRIVATE sein

en: !$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L
de: !$OMP DO-Schleifenvariable bei %L an Klausel statt PRIVATE oder LASTPRIVATE vorhanden

en: !$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line
de: !$OMP bei %C beginnt eine kommentierte Zeile, da es weder von Leerzeichen gefolgt wird noch eine Fortsetzungszeile ist

en: "#pragma disinterrupt %s" not used
de: »#pragma disinterrupt %s« nicht verwendet

en: "::" was expected after module nature at %C but was not found
de: "::" nach Modul-Eigenschaft bei %C erwartet, aber nicht gefunden

en: #include "..." search starts here:
de: #include "..." - Suche beginnt hier:

en: #include <...> search starts here:
de: #include <...> - Suche beginnt hier:

en: #pragma GCC coprocessor subclass '%c' already defined
de: #pragma GCC coprocessor subclass »%c« bereits definiert

en: #pragma GCC coprocessor subclass letter must be in [ABCD]
de: #pragma GCC coprocessor subclass Buchstabe muss in [ABCD] sein

en: #pragma GCC coprocessor width takes only 32 or 64
de: #pragma GCC coprocessor width akzeptiert nur 32 oder 64

en: #pragma GCC memregs must precede any function decls
de: #pragma GCC memregs muss vor allen Funktionsdeklarationen stehen

en: #pragma GCC memregs takes a number [0..16]
de: #pragma GCC memregs nimmt eine Zahl [0..16]

en: #pragma GCC optimize is not allowed inside functions
de: #pragma GCC optimize ist nicht innerhalb von Funktionen erlaubt

en: #pragma GCC optimize string... is badly formed
de: #pragma GCC optimize Zeichenkette... ist fehlerhaft

en: #pragma GCC option is not allowed inside functions
de: #pragma GCC option nicht innerhalb von Funktionen erlaubt

en: #pragma GCC target is not supported for this machine
de: #pragma GCC target wird für diese Maschine nicht unterstützt

en: #pragma GCC target string... is badly formed
de: #pragma GCC target Zeichenkette... ist fehlerhaft

en: #pragma GCC visibility must be followed by push or pop
de: #pragma GCC visibility muss von push oder pop gefolgt werden

en: #pragma GCC visibility push() must specify default, internal, hidden or protected
de: #pragma GCC visibility push() muss default, internal, hidden oder protected angeben

en: #pragma GHS endXXX does not match previous startXXX
de: #pragma GHS endXXX passt nicht zum vorherigen startXXX

en: #pragma GHS endXXXX found without previous startXXX
de: #pragma GHS endXXXX ohne vorheriges startXXX gefunden

en: #pragma extern_prefix not supported on this target
de: #pragma extern_prefix wird von diesem Ziel nicht unterstützt

en: #pragma implementation for %qs appears after file is included
de: #pragma implementation für %qs erscheint, nachdem Datei eingebunden wurde

en: #pragma io_volatile takes only on or off
de: #pragma io_volatile akzeptiert nur an oder aus

en: #pragma pack (pop) encountered without matching #pragma pack (push)
de: #pragma pack (pop) gefunden ohne passendes #pragma pack (push)

en: #pragma pack has no effect with -fpack-struct - ignored
de: #pragma pack hat mit -fpack-struct keinen Effekt - ignoriert

en: #pragma pack(pop, %E) encountered without matching #pragma pack(push, %E)
de: #pragma pack(pop, %E) gefunden ohne passendes #pragma pack(push, %E)

en: #pragma redefine_extname ignored due to conflict with __asm__ declaration
de: #pragma redefine_extname wegen Konflikt mit __asm__-Deklaration ignoriert

en: #pragma redefine_extname ignored due to conflict with previous #pragma redefine_extname
de: #pragma redefine_extname wegen Konflikt mit vorherigem #pragma redefine_extname ignoriert

en: #pragma redefine_extname ignored due to conflict with previous rename
de: #pragma redefine_extname wegen Konflikt mit vorheriger Umbenennung ignoriert

en: #pragma vtable no longer supported
de: #pragma vtable wird nicht mehr unterstützt

en: $ operand number used after format without operand number
de: $-Operandennummer nach Format ohne Operandennummer angegeben

en: %+D causes a section type conflict
de: %+D löst einen Abschnittstypkonflikt aus

en: %<#pragma GCC optimize (string [,string]...)%> does not have a final %<)%>
de: %<#pragma GCC optimize (Zeichenkette [,Zeichenkette]...)%> hat kein abschließendes %<)%>

en: %<#pragma GCC optimize%> is not a string or number
de: %<#pragma GCC optimize%> ist keine Zeichenkette oder Zahl

en: %<#pragma GCC option%> is not a string
de: %<#pragma GCC option%> ist keine Zeichenkette

en: %<#pragma GCC pch_preprocess%> must be first
de: %<#pragma GCC pch_preprocess%> muss zuerst kommen

en: %<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_options%>
de: %<#pragma GCC pop_options%> ohne zugehöriges %<#pragma GCC push_options%>

en: %<#pragma GCC target (string [,string]...)%> does not have a final %<)%>
de: %<#pragma GCC target (Zeichenkette [,Zeichenkette]...)%> hat kein abschließendes %<)%>

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported for C++
de: %<#pragma STDC FLOAT_CONST_DECIMAL64%> wird für C++ nicht unterstützt

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported on this target
de: %<#pragma STDC FLOAT_CONST_DECIMAL64%> wird auf diesem Ziel nicht unterstützt

en: %<#pragma align%> must appear before the declaration of %D, ignoring
de: %<#pragma align%> muss vor der Deklaration von %D auftreten, ignoriert

en: %<#pragma omp barrier%> may only be used in compound statements
de: %<#pragma omp barrier%> darf nur in Verbundanweisungen verwendet werden

en: %<#pragma omp flush%> may only be used in compound statements
de: %<#pragma omp flush%> darf nur in Verbundanweisungen verwendet werden

en: %<#pragma omp section%> may only be used in %<#pragma omp sections%> construct
de: %<#pragma omp section%> darf nur in %<#pragma omp sections%>-Konstrukt verwendet werden

en: %<#pragma omp taskwait%> may only be used in compound statements
de: %<#pragma omp taskwait%> darf nur in Verbundanweisungen verwendet werden

en: %<#pragma%> is not allowed here
de: %<#pragma%> ist hier nicht erlaubt

en: %<%%%> constraint used with last operand
de: %<%%%>-Bedingung mit letztem Operanden verwendet

en: %<%%%c%> yields only last 2 digits of year
de: %<%%%c%> liefert nur die letzten 2 Ziffern des Jahres

en: %<%%%c%> yields only last 2 digits of year in some locales
de: %<%%%c%> liefert in manchen Locales nur die letzten 2 Ziffern des Jahres

en: %<%D::%D%> is not a member of %qT
de: %<%D::%D%> ist kein Element von %qT

en: %<%E::%E%> has not been declared
de: %<%E::%E%> wurde nicht deklariert

en: %<%E::%E%> is not a class or namespace
de: %<%E::%E%> ist keine Klasse oder Namensbereich

en: %<%E::%E%> is not a class, namespace, or enumeration
de: %<%E::%E%> ist keine Klasse, Namensbereich oder Aufzählung

en: %<%E::%E%> is not a type
de: %<%E::%E%> ist kein Typ

en: %<%T::%D%> is not a valid declarator
de: %<%T::%D%> ist kein gültiger Deklarator

en: %<%T::%D%> names constructor
de: %<%T::%D%> benennt Konstruktor

en: %<%T::%D%> names constructor in %qT
de: %<%T::%D%> benennt Konstruktor in %qT

en: %<%T::%D%> names destructor
de: %<%T::%D%> benennt Destruktor

en: %<%T::%D%> names the constructor, not the type
de: %<%T::%D%> benennt Konstruktor, nicht den Typ

en: %<%T::%E%> has not been declared
de: %<%T::%E%> wurde nicht deklariert

en: %<%T::%E%> is not a type
de: %<%T::%E%> ist kein Typ

en: %<%T::%E%> names the constructor, not the type
de: %<%T::%E%> benennt den Konstruktor, nicht den Typ

en: %<%c%E%> not found in protocol(s)
de: %<%c%E%> nicht in Protokoll(en) gefunden

en: %<%s %E%> declared inside parameter list
de: %<%s %E%> innerhalb Parameterliste deklariert

en: %<&%> constraint used with no register class
de: %<&%>-Bedingung ohne Registerklasse verwendet

en: %<-%s%> conflicts with the other architecture options, which specify a %s processor
de: %<-%s%> steht in Konflikt mit den anderen Architekturoptionen, die einen %s-Prozessor angeben

en: %<-femit-struct-debug-detailed=dir:...%> must allow at least as much as %<-femit-struct-debug-detailed=ind:...%>
de: %<-femit-struct-debug-detailed=dir:...%> muss zumindest so viel wie %<-femit-struct-debug-detailed=ind:...%> erlauben

en: %<-fobjc-exceptions%> is required to enable Objective-C exception syntax
de: %<-fobjc-exceptions%> verwenden, um Syntax für Objective-C-Ausnahmen einzuschalten

en: %<-fobjc-gc%> is ignored for %<-fgnu-runtime%>
de: %<-fobjc-gc%> wird für %<-fgnu-runtime%> ignoriert

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>
de: %<-fobjc-sjlj-exceptions%> wird für %<-fgnu-runtime%> ignoriert

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2
de: %<-fobjc-sjlj-exceptions%> wird für %<-fnext-runtime%> ignoriert, wenn %<-fobjc-abi-version%> >= 2

en: %<-fobjc-sjlj-exceptions%> is the only supported exceptions system for %<-fnext-runtime%> with %<-fobjc-abi-version%> < 2
de: %<-fobjc-sjlj-exceptions%> ist das einzige unterstützte Ausnahmesystem für %<-fnext-runtime%> mit %<-fobjc-abi-version%> < 2

en: %<-fsplit-stack%> currently only supported on GNU/Linux
de: %<-fsplit-stack%> wird derzeit nur auf GNU/Linux unterstützt

en: %<-fsplit-stack%> is not supported by this compiler configuration
de: %<-fsplit-stack%> wird von dieser Compilerkonfiguration nicht unterstützt

en: %<-fsplit-stack%> requires assembler support for CFI directives
de: %<-fsplit-stack%> erfordert Assemblerunterstützung für CFI-Anweisungen

en: %<-gnat%> misspelled as %<-gant%>
de: %<-gnat%> falsch buchstabiert als %<-gant%>

en: %<-march=%s%> is not compatible with the selected ABI
de: %<-march=%s%> ist mit dem ausgewählten ABI unverträglich

en: %<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead
de: %<-mcpu=%> ist veraltet. Stattdessen %<-mtune=%> oder %<-march=%> verwenden.

en: %<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead
de: %<-mfused-madd%> ist veraltet; stattdessen %<-ffp-contract=%> verwenden

en: %<-mgp32%> and %<-mfp64%> can only be combined if the target supports the mfhc1 and mthc1 instructions
de: %<-mgp32%> und %<-mfp64%> können nur kombiniert werden, wenn das Ziel die Befehle mfhc1 und mthc1 unterstützt

en: %<-mgp32%> and %<-mfp64%> can only be combined when using the o32 ABI
de: %<-mgp32%> und %<-mfp64%> können nur kombiniert werden, wenn o32-ABI verwendet wird

en: %<-mgp32%> used with a 64-bit ABI
de: %<-mgp32%> mit einem 64-Bit-ABI verwendet

en: %<-mgp64%> used with a 32-bit ABI
de: %<-mgp64%> mit einem 32-Bit-ABI verwendet

en: %<-mgp64%> used with a 32-bit processor
de: %<-mgp64%> mit einem 32-Bit-Prozessor verwendet

en: %<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead
de: %<-mintel-syntax%> und %<-mno-intel-syntax%> sind veraltet; stattdessen %<-masm=intel%> und %<-masm=att%> verwenden

en: %<-mips3d%> requires %<-mpaired-single%>
de: %<-mips3d%> erfordert %<-mpaired-single%>

en: %<-mno-gpopt%> needs %<-mexplicit-relocs%>
de: %<-mno-gpopt%> erfordert %<-mexplicit-relocs%>

en: %<-msse5%> was removed
de: %<-msse5%> wurde entfernt

en: %<-x %s%> after last input file has no effect
de: %<-x %s%> hinter letzter Eingabedatei hat keine Wirkung

en: %<...%> as arguments.)
de: %<...%> als Argumente.)

en: %<...%> handler must be the last handler for its try block
de: %<...%>-Behandler muss der letzte Behandler für seinen »try«-Block sein

en: %<...%> has invalid operand number
de: %<...%> hat ungültige Operandenzahl

en: %<::%D%> has not been declared
de: %<::%D%> wurde nicht deklariert

en: %<::%E%> has not been declared
de: %<::%E%> wurde nicht deklariert

en: %<::%E%> is not a class or namespace
de: %<::%E%> ist keine Klasse oder Namensbereich

en: %<::%E%> is not a class, namespace, or enumeration
de: %<::%E%> ist keine Klasse, Namensbereich oder Aufzählung

en: %<::%E%> is not a type
de: %<::%E%> ist kein Typ

en: %<::main%> must return %<int%>
de: %<::main%> muss %<int%> zurückgeben

en: %<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>
de: %<<:%> ist eine andere Schreibweise für %<[%>. Leerraum zwischen %<<%> und %<::%> einfügen

en: %<<::%> cannot begin a template-argument list
de: %<<::%> kann keine Templateargumentliste einleiten

en: %<>>%> operator will be treated as two right angle brackets in C++0x
de: Operator %<>>%> wird in C++0x als zwei spitze schließende Klammern behandelt

en: %<>>%> should be %<> >%> within a nested template argument list
de: %<>>%> sollte innerhalb einer geschachtelten Templateargumentliste %<> >%> sein

en: %<@dynamic%> is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es kein %<@dynamic%>

en: %<@dynamic%> not in @implementation context
de: %<@dynamic%> nicht in @implementation-Kontext

en: %<@dynamic%> requires the @interface of the class to be available
de: %<@dynamic%> erfordert Verfügbarkeit des @interface der Klasse

en: %<@encode%> must specify a type as an argument
de: %<@encode%> muss als Argument einen Typen angeben

en: %<@end%> missing in implementation context
de: %<@end%> fehlt in Implementationskontext

en: %<@end%> must appear in an @implementation context
de: %<@end%> muss in einem @implementation-Kontext auftreten

en: %<@synchronized%> argument is not an object
de: %<@synchronized%>-Argument ist kein Objekt

en: %<@synthesize%> can not be used in categories
de: %<@synthesize%> kann nicht in Kategorien verwendet werden

en: %<@synthesize%> is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es kein %<@synthesize%>

en: %<@synthesize%> not in @implementation context
de: %<@synthesize%> nicht in @implementation-Kontext

en: %<@synthesize%> requires the @interface of the class to be available
de: %<@synthesize%> erfordert Verfügbarkeit des @interface der Klasse

en: %<@throw%> (rethrow) used outside of a @catch block
de: %<@throw%> (rethrow) außerhalb von »@catch«-Block verwendet

en: %<@throw%> argument is not an object
de: %<@throw%>-Argument ist kein Objekt

en: %<@try%> without %<@catch%> or %<@finally%>
de: %<@try%> ohne %<@catch%> oder %<@finally%>

en: %<[*]%> not allowed in other than function prototype scope
de: %<[*]%> außerhalb des Bereichs des Funktionsprototypen nicht erlaubt

en: %<[*]%> not in a declaration
de: %<[*]%> nicht in einer Deklaration

en: %<_Sat%> is used without %<_Fract%> or %<_Accum%>
de: %<_Sat%> ohne %<_Fract%> oder %<_Accum%> verwendet

en: %<__BELOW100__%> attribute only applies to variables
de: Attribut %<__BELOW100__%> bezieht sich nur auf Variablen

en: %<__alignof%> applied to a bit-field
de: %<__alignof%> auf Bitfeld angewandt

en: %<__builtin_longjmp%> second argument must be 1
de: Zweites Argument für %<__builtin_longjmp%> muss 1 sein

en: %<__builtin_next_arg%> called without an argument
de: %<__builtin_next_arg%> ohne Argument gerufen

en: %<__gcc_host_wide_int__%> is not defined as %<long%> or %<long long%>
de: %<__gcc_host_wide_int__%> ist nicht als %<long%> oder %<long long%> definiert

en: %<__gcc_host_wide_int__%> is not defined as a type
de: %<__gcc_host_wide_int__%> ist nicht als Typ definiert

en: %<__int128%> invalid for %qs
de: %<__int128%> ungültig für %qs

en: %<__int128%> is not supported by this target
de: %<__int128%> wird von diesem Ziel nicht unterstützt

en: %<__int128%> is not supported for this target
de: <__int128%> wird für dieses Ziel nicht unterstützt

en: %<__label__%> not at the beginning of a block
de: %<__label__%> nicht am Anfang eines Blocks

en: %<__thread%> before %<extern%>
de: %<__thread%> vor %<extern%>

en: %<__thread%> before %<static%>
de: %<__thread%> vor %<static%>

en: %<__thread%> before %qD
de: %<__thread%> vor %qD

en: %<__thread%> used with %<auto%>
de: %<__thread%> mit %<auto%> verwendet

en: %<__thread%> used with %<register%>
de: %<__thread%> mit %<register%> verwendet

en: %<__thread%> used with %<typedef%>
de: %<__thread%> mit %<typedef%> verwendet

en: %<__thread%> used with %qE
de: %<__thread%> mit %qE verwendet

en: %<and%> of mutually exclusive equal-tests is always 0
de: »und« sich gegenseitig ausschließender Gleichheits-Tests ist immer 0

en: %<asm%> operand constraint incompatible with operand size
de: %<asm%>-Operandenbedingung inkompatibel mit Operandengröße

en: %<asm%> operand has impossible constraints
de: %<asm%>-Operand hat unmögliche Nebenbedingungen

en: %<asm%> operand requires impossible reload
de: %<asm%>-Operand erfordert unmögliches Neuladen

en: %<asm%> specifiers are not permitted on non-static data members
de: %<asm%>-Symbole sind an nicht statischen Datenelementen nicht erlaubt

en: %<auto%> in file-scope empty declaration
de: %<auto%> in leerer Deklaration im Datei-Gültigkeitsbereich

en: %<bank_switch%> has no effect on non-interrupt functions
de: %<bank_switch%> hat auf Nicht-Interrupt-Funktionen keine Auswirkung

en: %<const%> and %<volatile%> function specifiers on %qD invalid in field declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Felddeklaration

en: %<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Parameterdeklaration

en: %<const%> and %<volatile%> function specifiers on %qD invalid in type declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Typdeklaration

en: %<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Variablendeklaration

en: %<constexpr%> cannot appear in a typedef declaration
de: %<constexpr%> kann nicht in typedef-Deklaration auftreten

en: %<constexpr%> cannot be used for type declarations
de: %<constexpr%> kann nicht für Typdeklarationen verwendet werden

en: %<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type
de: %<constexpr%> erforderlich für Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit nicht eingebautem Typ

en: %<default%> label not within a switch statement
de: %<default%>-Marke nicht innerhalb einer switch-Anweisung

en: %<dynamic_cast%> not permitted with -fno-rtti
de: %<dynamic_cast%> ist nicht mit -fno-rtti erlaubt

en: %<else%> without a previous %<if%>
de: %<else%> ohne vorheriges %<if%>

en: %<enum %E%> declared in %<for%> loop initial declaration
de: %<enum %E%> in Anfangsdeklaration einer %<for%>-Schleife deklariert

en: %<explicit%> can only be specified for constructors
de: %<explicit%> kann nur für Konstruktoren angegeben werden

en: %<externally_visible%> attribute have effect only on public objects
de: Attribut %<externally_visible%> wirkt sich nur auf öffentliche Objekte aus

en: %<fast_interrupt%> attribute directive ignored
de: Direktive des Attributes %<fast_interrupt%> ignoriert

en: %<for%> loop initial declarations are only allowed in C99 mode
de: Anfangsdeklarationen in %<for%>-Schleifen sind nur im C99-Modus erlaubt

en: %<friend%> can only be specified inside a class
de: %<friend%> kann nur innerhalb einer Klasse angegeben werden

en: %<friend%> used outside of class
de: %<friend%> außerhalb einer Klasse verwendet

en: %<gnu_inline%> attribute present on %q+D
de: Attribut %<gnu_inline%> vorhanden bei %q+D

en: %<inline%> in empty declaration
de: %<inline%> in leerer Deklaration

en: %<inline%> is not allowed in declaration of friend template specialization %qD
de: %<inline%> ist nicht in Deklaration der friend-Template-Spezialisierung %qD erlaubt

en: %<inline%> specified for friend class declaration
de: %<inline%> für friend-Klassen-Deklaration angegeben

en: %<inline%> specifier invalid for function %qs declared out of global scope
de: %<inline%> ungültig für außerhalb des globalen Gültigkeitsbereiches deklarierte Funktion %qs

en: %<location_t%> is not defined as a type
de: %<location_t%> ist nicht als ein Typ definiert

en: %<locus%> is not defined as a type
de: %<locus%> ist nicht als ein Typ definiert

en: %<long long long%> is too long for GCC
de: %<long long long%> ist für GCC zu lang

en: %<long long%> invalid for %qs
de: %<long long%> ungültig für %qs

en: %<long%> and %<short%> specified together for %qs
de: %<long%> und %<short%> für %qs gleichzeitig angegeben

en: %<long%> invalid for %qs
de: %<long%> ungültig für %qs

en: %<long%> or %<short%> invalid for %qs
de: %<long%> oder %<short%> ungültig für %qs

en: %<long%> or %<short%> specified with char for %qs
de: %<long%> oder %<short%> mit »char« für %qs angegeben

en: %<long%> switch expression not converted to %<int%> in ISO C
de: %<long%> switch-Ausdruck nicht nach »int« konvertiert in ISO C

en: %<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs
de: %<long%>, %<int%>, %<short%> oder %<char%> ungültig für %qs

en: %<namespace%> definition is not allowed here
de: %<namespace%>-Definition ist hier nicht erlaubt

en: %<noreturn%> function does return
de: %<noreturn%>-Funktion kehrt zurück

en: %<num_threads%> value must be positive
de: Wert von %<num_threads%> muss positiv sein

en: %<operator delete%> must return type %qT
de: %<operator delete%> muss Typ %qT zurück geben

en: %<operator delete%> takes type %qT as first parameter
de: %<operator delete%> nimmt Typ %qT als ersten Parameter

en: %<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)
de: %<operator new%> darf nicht NULL zurückgeben, außer es ist mit %<throw()%> deklariert (oder -fcheck-new ist eingeschaltet)

en: %<operator new%> must return type %qT
de: %<operator new%> muss Typ %qT zurück geben

en: %<operator new%> takes type %<size_t%> (%qT) as first parameter
de: %<operator new%> nimmt Typ %<size_t%> (%qT) als ersten Parameter

en: %<operator=%> should return a reference to %<*this%>
de: %<operator=%> sollte eine Referenz auf %<*this%> zurück geben

en: %<or%> of unmatched not-equal tests is always 1
de: »oder« nicht passender Ungleichheits-Tests ist immer 1

en: %<register%> in file-scope empty declaration
de: %<register%> in leerer Deklaration im Datei-Gültigkeitsbereich

en: %<return%> with a value, in function returning void
de: %<return%> mit Wert in void zurückgebender Funktion

en: %<return%> with no value, in function returning non-void
de: %<return%> ohne Wert in nicht-void zurückgebender Funktion

en: %<short%> invalid for %qs
de: %<short%> ungültig für %qs

en: %<short%> or %<long%> invalid for %qs
de: %<short%> oder %<long%> ungültig für %qs

en: %<signed%> and %<unsigned%> specified together for %qs
de: %<signed%> und %<unsigned%> für %qs gleichzeitig angegeben

en: %<signed%> or %<unsigned%> invalid for %qs
de: %<signed%> oder %<unsigned%> ungültig für %qs

en: %<sizeof%> applied to a bit-field
de: %<sizeof%> auf ein Bitfeld angewandt

en: %<static%> may not be used when defining (as opposed to declaring) a static data member
de: %<static%> darf nicht bei der Definition (im Gegensatz zu Deklaration) eines statischen Datenelementes verwendet werden

en: %<static%> specified invalid for function %qs declared out of global scope
de: %<static%> ungültig für außerhalb des globalen Gültigkeitsbereiches deklarierte Funktion %qs

en: %<struct %E%> declared in %<for%> loop initial declaration
de: %<struct %E%> in Anfangsdeklaration einer %<for%>-Schleife deklariert

en: %<template%> (as a disambiguator) is only allowed within templates
de: %<template%> (zur Erklärung) ist nur innerhalb von Templates erlaubt

en: %<this%> is unavailable for static member functions
de: %<this%> ist für statische Elementfunktionen nicht verfügbar

en: %<this%> may not be used in this context
de: %<this%> darf in diesem Kontext nicht verwendet werden

en: %<this%> was not captured for this lambda function
de: %<this%> wurde für diese Lambda-Funktion nicht aufgefangen

en: %<threadprivate%> %qD is not file, namespace or block scope variable
de: %<threadprivate%> %qD ist nicht Datei-, Namens- oder Blockbereichsvariable

en: %<threadprivate%> %qE directive not in %qT definition
de: Direktive %<threadprivate%> %qE nicht in Definition von %qT

en: %<threadprivate%> %qE has incomplete type
de: %<threadprivate%> %qE hat unvollständigen Typen

en: %<trap%> and %<far%> attributes are not compatible, ignoring %<far%>
de: Attribute %<trap%> und %<far%> sind unverträglich, %<far%> wird ignoriert

en: %<trap%> attribute is already used
de: Attribut %<trap%> wird bereits verwendet

en: %<tree%> is not defined as a pointer type
de: %<tree%> ist nicht als ein Zeigertyp definiert

en: %<tree%> is not defined as a type
de: %<tree%> ist nicht als ein Typ definiert

en: %<typedef%> was ignored in this declaration
de: %<typedef%> wurde in dieser Deklaration ignoriert

en: %<typeid%> operator cannot appear in a constant-expression
de: %<typeid%>-Operator kann nicht in einem Konstanten-Ausdruck auftreten

en: %<typename %T::%D%> names %q#T, which is not a class template
de: %<typename %T::%D%> benennt %q#T, was kein Klassentemplate ist

en: %<typename %T::%D%> names %q#T, which is not a type
de: %<typename %T::%D%> benennt %q#T, was kein Typ ist

en: %<typeof%> applied to a bit-field
de: %<typeof%> auf ein Bitfeld angewandt

en: %<union %E%> declared in %<for%> loop initial declaration
de: %<union %E%> in Anfangsdeklaration einer %<for%>-Schleife deklariert

en: %<va_start%> used in function with fixed args
de: %<va_start%> in Funktion mit fester Parameterzahl verwendet

en: %<virtual%> outside class declaration
de: %<virtual%> außerhalb einer Klassendeklaration

en: %<virtual%> specified more than once in base-specified
de: %<virtual%> mehr als einmal in Basisspezifikation angegeben

en: %<void%> as only parameter may not be qualified
de: %<void%> kann nicht als einzelner Parameter qualifiziert werden

en: %<void%> must be the only parameter
de: %<void%> muss der einzige Parameter sein

en: %<weakref%> attribute ignored because function is defined
de: Attribut %<weakref%> ignoriert, da Funktion bereits definiert ist

en: %<weakref%> attribute ignored because variable is initialized
de: Attribut %<weakref%> ignoriert, da Variable bereits initialisiert ist

en: %<weakref%> attribute should be accompanied with an %<alias%> attribute
de: Attribut %<weakref%> sollte von Attribut %<alias%> begleitet werden

en: %D renamed after being referenced in assembly
de: %D nach Referenzierung in Assemblierung umbenannt

en: %E qualifier ignored on asm
de: %E-Qualifizierer für asm ignoriert

en: %Kcall to %D might overflow destination buffer
de: %KAufruf von %D könnte Zielpuffer überlaufen lassen

en: %Kcall to %D will always overflow destination buffer
de: %KAufruf von %D wird den Zielpuffer immer überlaufen lassen

en: %Kcall to %qs declared with attribute error: %s
de: %KAufruf von %qs mit Attributfehler deklariert: %s

en: %Kcall to %qs declared with attribute warning: %s
de: %KAufruf von %qs mit Attributwarnung deklariert: %s

en: %Kfirst argument of %D must be a pointer, second integer constant
de: %Kerstes Argument von %D muss ein Zeiger, das zweite eine Ganzzahlkonstante sein

en: %Kinvalid use of %<__builtin_va_arg_pack ()%>
de: %Kungültige Verwendung von %<__builtin_va_arg_pack ()%>

en: %Kinvalid use of %<__builtin_va_arg_pack_len ()%>
de: %Kungültige Verwendung von %<__builtin_va_arg_pack_len ()%>

en: %Klast argument of %D is not integer constant between 0 and 3
de: %Kletztes Argument von %D ist keine Ganzzahlkonstante zwischen 0 und 3

en: %c REDUCTION variable '%s' at %L must be of numeric type, got %s
de: %c REDUCTION-Variable »%s« muss bei %L numerischen Typ haben, %s erhalten

en: %d constructor found
     | %d constructors found
de[0]: Einen Konstruktor gefunden
de[1]: %d Konstruktoren gefunden

en: %d destructor found
     | %d destructors found
de[0]: Einen Destruktor gefunden
de[1]: %d Destruktoren gefunden

en: %d exits recorded for loop %d (having %d exits)
de: %d Ausgänge für Schleife %d (mit %d Ausgängen) aufgezeichnet

en: %d frame table found
     | %d frame tables found
de[0]: Eine Rahmentabelle gefunden
de[1]: %d Rahmentabellen gefunden

en: %d least significant bits of %s are ignored
de: %d niederwertigste Bits von %s werden ignoriert

en: %i-bit mode not compiled in
de: %i-Bit-Modus nicht einkompiliert

en: %q#D conflicts with previous using declaration %q#D
de: %q#D steht mit vorheriger %<using%>-Deklaration %q#D in Konflikt

en: %q#D hides constructor for %q#T
de: %q#D verdeckt Konstruktor für %q#T

en: %q#D is a static data member; it can only be initialized at its definition
de: %q#D« ist ein statisches Datenelement; es kann nur bei seiner Definition initialisiert werden

en: %q#D is not a non-static data member of %qT
de: %q#D ist kein Nicht-static-Datenelement von %qT

en: %q#D is not a static member of %q#T
de: %q#D ist kein statisches Element von %q#T

en: %q#D is not a valid template argument for type %qT because a reference variable does not have a constant address
de: %q#D ist kein gültiges Templateargument für Typ %qT, weil eine Referenzvariable keine konstante Adresse hat

en: %q#D is not const
de: %q#D ist nicht konstant

en: %q#D is volatile
de: %q#D ist volatile

en: %q#D not declared in class
de: %q#D nicht in Klasse deklariert

en: %q#D redeclared as different kind of symbol
de: %q#D als andere Symbolart redeklariert

en: %q#T has no user-provided default constructor
de: %q#T hat keinen benutzerdefinierten Default-Konstruktor

en: %q#T has pointer data members
de: %q#T hat Zeigertypen als Elemente

en: %q#T has virtual functions and accessible non-virtual destructor
de: %q#T hat virtuelle Funktionen und erreichbaren nicht-virtuellen Destruktor

en: %q#T is not a class
de: %q#T ist keine Klasse

en: %q#T is not a class or a namespace
de: %q#T ist keine Klasse oder Namensbereich

en: %q#T is not a template
de: %q#T ist kein Template

en: %q#T is not a valid type for a template constant parameter
de: %q#T ist kein gültiger Typ für einen Templatekonstanten-Parameter

en: %q#T only defines a private destructor and has no friends
de: %q#T definiert nur einen privaten Destruktor und hat keine »friends«

en: %q#T only defines private constructors and has no friends
de: %q#T definiert nur private Konstruktoren und hat keine »friends«

en: %q#T used where a %qT was expected
de: %q#T verwendet, wo %qT erwartet wurde

en: %q#T used where a floating point value was expected
de: %q#T verwendet, wo ein Gleitkommawert erwartet wurde

en: %q+#D cannot be declared
de: %q+#D kann nicht deklariert werden

en: %q+#D cannot be overloaded
de: %q+#D kann nicht überladen werden

en: %q+#D does not refer to the unqualified type, so it is not used for linkage
de: %q+#D verweist nicht auf den unqualifizierten Typen, also wird es nicht zum Binden verwendet

en: %q+#D invalid; an anonymous struct can only have non-static data members
de: %q+#D ungültig; eine anonyme struct kann nur nicht-statische Datenelemente haben

en: %q+#D invalid; an anonymous union can only have non-static data members
de: %q+#D ungültig; eine anonyme Union kann nur nicht-statische Datenelemente haben

en: %q+#D is inaccessible
de: %q+#D ist unzugänglich

en: %q+#D is private
de: %q+#D ist privat

en: %q+#D is protected
de: %q+#D ist geschützt

en: %q+#D previously defined here
de: %q+#D wurde vorher hier definiert

en: %q+#D, declared using anonymous type, is used but never defined
de: mit anonymem Typ deklariertes %q+#D wird verwendet, aber nirgendwo definiert

en: %q+#D, declared using local type %qT, is used but never defined
de: mit lokalem Typ %2$qT deklariertes %1$q+#D wird verwendet, aber nirgendwo definiert

en: %q+D aliased to external symbol %qE
de: %q+D als Alias für externes Symbol %qE

en: %q+D aliased to undefined symbol %qE
de: %q+D als Alias für undefiniertes Symbol %qE

en: %q+D already declared with dllexport attribute: dllimport ignored
de: %q+D bereits mit Attribut »dllimport« deklariert: »dllimport« ignoriert

en: %q+D causes a section type conflict
de: %q+D löst einen Abschnittstypkonflikt aus

en: %q+D contains empty classes which may cause base classes to be placed at different locations in a future version of GCC
de: %q+D enthält leere Klassen, die in zukünftigen GCC-Versionen die Basisklassen an andere Orte verschieben können

en: %q+D declared as a friend
de: %q+D als »friend« deklariert

en: %q+D declared here
de: %q+D hier deklariert

en: %q+D declared to take const reference, but implicit declaration would take non-const
de: %q+D mit Eingabe einer konstanten Referenz deklariert, aber implizite Deklaration würde nicht-Konstante annehmen

en: %q+D declared to take non-const reference cannot be defaulted in the class body
de: mit Eingabe einer nicht konstanten Referenz deklariertes %q+D kann im Klassenkörper nicht vorbelegt werden

en: %q+D declared with an exception specification
de: %q+D mit einer Ausnahmespezifikation deklariert

en: %q+D defined both normally and as %qE attribute
de: %q+D sowohl normal als auch als Attribut %qE definiert

en: %q+D defined but not used
de: %q+D definiert, aber nicht verwendet

en: %q+D has a previous declaration as %q#D
de: %q+D hat eine vorherige Deklaration als %q#D

en: %q+D has a previous declaration here
de: %q+D hat eine vorherige Deklaration hier

en: %q+D has incomplete type
de: %q+D hat unvollständigen Typen

en: %q+D invalid in %q#T
de: %q+D ungültig in %q#T

en: %q+D is static but declared in inline function %qD which is not static
de: %q+D ist statisch, aber in Inline-Funktion %qD deklariert, was nicht statisch ist

en: %q+D is too small to hold all values of %q#T
de: %q+D ist zu klein um alle Werte von %q#T aufzunehmen

en: %q+D is usually a function
de: %q+D ist üblicherweise eine Funktion

en: %q+D may not be static because it is a member of a union
de: %q+D kann nicht static sein, da es ein Union-Element ist

en: %q+D may not have reference type %qT because it is a member of a union
de: %q+D darf keinen Referenztyp %qT haben, da es ein Element einer Union ist

en: %q+D redeclared as different kind of symbol
de: %q+D als andere Symbolart redeklariert

en: %q+D redeclared inline with %<gnu_inline%> attribute
de: %q+D mit Attribut %<gnu_inline%> »inline« redeklariert

en: %q+D redeclared inline without %<gnu_inline%> attribute
de: %q+D ohne Attribut %<gnu_inline%> »inline« redeklariert

en: %q+D redeclared without dllimport attribute after being referenced with dll linkage
de: %q+D ohne Attribut »dllimport« redeklariert, nachdem es mit dll-Bindung referenziert wurde

en: %q+D redeclared without dllimport attribute: previous dllimport ignored
de: %qD ohne Attribut »dllimport« redeklariert: vorheriges »dllimport« ignoriert

en: %q+D takes only zero or two arguments
de: %q+D benötigt entweder null oder zwei Argumente

en: %q+D used prior to declaration
de: %q+D vor Deklaration verwendet

en: %q+D was hidden
de: %q+D war versteckt

en: %q+D will be initialized after
de: %q+D wird initialisiert nach

en: %q+D: visibility attribute ignored because it
de: %q+D: Sichtbarkeitsattribut ignoriert, da es

en: %q+D:'selectany' attribute applies only to initialized objects
de: %q+D:Attribut »selectany« bezieht sich nur auf initialisierte Objekte

en: %q+E is not a constant expression
de: %q+E ist kein Konstantenausdruck

en: %q+F declared %<static%> but never defined
de: %q+F als %<static%> deklariert, aber nirgendwo definiert

en: %q+F used but never defined
de: %q+F verwendet, aber nirgendwo definiert

en: %q+T has a previous declaration here
de: %q+T hat eine vorherige Deklaration hier

en: %qD appears more than once in data clauses
de: %qD tritt in Datenklausel mehrfach auf

en: %qD attribute directive ignored
de: Attribut-Anweisung %qD wird ignoriert

en: %qD attribute is meaningless since members of the anonymous namespace get local symbols
de: Attribut %qD ist bedeutungslos, da die Elemente des anonymen Namensraums lokale Symbole erhalten

en: %qD attribute requires a single NTBS argument
de: Attribut %qD erfordert ein einzelnes NTBS-Argument

en: %qD cannot appear in a constant-expression
de: %qD kann nicht in Konstanten-Ausdruck auftreten

en: %qD cannot be declared as constexpr
de: %qD kann nicht als »constexpr« deklariert werden

en: %qD cannot be declared virtual, since it is always static
de: %qD kann nicht als virtuell deklariert werden, da es immer statisch ist

en: %qD cannot be defaulted
de: %qD kann nicht vorgegeben werden

en: %qD cannot be initialized by a non-constant expression when being declared
de: %qD kann bei der Deklaration nicht von nicht konstantem Ausdruck initialisiert werden

en: %qD cannot be thread-local because it has non-trivial type %qT
de: %qD kann nicht Thread-lokal sein, weil es nichttrivialen Typen %qT hat

en: %qD cannot have default arguments
de: %qD kann keine Standardargumente haben

en: %qD changed semantics in GCC 4.4
de: %qD hat neue Semantik in GCC 4.4

en: %qD conflicts with used function
de: %qD steht mit verwendeter Funktion in Konflikt

en: %qD declared %<constexpr%> outside its class
de: %qD außerhalb seiner Klasse als %<constexpr%> deklariert

en: %qD declared as a %<virtual%> field
de: %qD als ein %<virtual%> Feld deklariert

en: %qD declared as a %<virtual%> parameter
de: %qD als ein %<virtual%> Parameter deklariert

en: %qD declared as a %<virtual%> type
de: %qD als ein %<virtual%> Typ deklariert

en: %qD declared as a %<virtual%> variable
de: %qD als eine %<virtual%> Variable deklariert

en: %qD declared as a non-parameter
de: %qD als Nicht-Parameter deklariert

en: %qD declared as an %<inline%> field
de: %qD als ein %<inline%> Feld deklariert

en: %qD declared as an %<inline%> parameter
de: %qD als ein %<inline%> Parameter deklariert

en: %qD declared as an %<inline%> type
de: %qD als ein %<inline%> Typ deklariert

en: %qD declared as an %<inline%> variable
de: %qD als eine %<inline%> Variable deklariert

en: %qD declared as reference but not initialized
de: %qD als Referenz deklariert, aber nicht initialisiert

en: %qD declared here
de: %qD hier deklariert

en: %qD declared virtual cannot be defaulted in the class body
de: als virtuell deklariertes %qD kann nicht im Klassenkörper vordefiniert werden

en: %qD does not have integral or enumeration type
de: %qD hat keinen Ganzzahl- oder Aufzählungstyp

en: %qD has already been defined
de: %qD wurde bereits definiert

en: %qD has an incomplete type
de: %qD hat unvollständigen Typ

en: %qD has incomplete type
de: %qD hat unvollständigen Typen

en: %qD has no member named %qE
de: %qD hat kein Element namens %qE

en: %qD has the same name as the class in which it is declared
de: %qD hat den gleichen Namen wie die Klasse, in der es deklariert wurde

en: %qD is a namespace
de: %qD ist ein Namensbereich

en: %qD is already a friend of %qT
de: %qD ist bereits ein »friend« von %qT

en: %qD is already a friend of class %qT
de: %qD ist bereits ein »friend« der Klasse %qT

en: %qD is already declared in this scope
de: %qD wurde in diesem Gültigkeitsbereich bereits deklariert

en: %qD is already defined in %qT
de: %qD ist bereits in %qT definiert

en: %qD is already defined in class %qT
de: %qD ist bereits in Klasse %qT definiert

en: %qD is already defined in the class %qT
de: %qD ist bereits in der Klasse %qT definiert

en: %qD is an enumeration template
de: %qD ist ein Aufzählungstemplate

en: %qD is both a direct base and an indirect virtual base
de: %qD ist sowohl eine direkte Basis als auch eine indirekte virtuelle Basis

en: %qD is deprecated (declared at %s:%d)
de: %qD ist veraltet (deklariert bei %s:%d)

en: %qD is deprecated (declared at %s:%d): %s
de: %qD ist veraltet (deklariert bei %s:%d): %s

en: %qD is implicitly deleted because the default definition would be ill-formed:
de: %qD wird implizit gelöscht, da die Standarddefinition ungültig wäre:

en: %qD is normally a non-static function
de: %qD ist normalerweise eine nicht-statische Funktion

en: %qD is not %<constexpr%>
de: %qD ist nicht %<constexpr%>

en: %qD is not a class or namespace
de: %qD ist keine Klasse oder Namensbereich

en: %qD is not a constexpr function
de: %qD ist keine Funktion mit konstantem Audruck

en: %qD is not a function template
de: %qD ist kein Funktionstemplate

en: %qD is not a member of %qD
de: %qD ist kein Element von %qD

en: %qD is not a member of %qT
de: %qD ist kein Element von %qT

en: %qD is not a member template function
de: %qD ist keine Elementtemplatefunktion

en: %qD is not a namespace-name
de: %qD ist kein Namensbereichs-Name

en: %qD is not a static data member of a class template
de: %qD ist kein statisches Datenelement eines Klassentemplates

en: %qD is not a template
de: %qD ist kein Template

en: %qD is not a template function
de: %qD ist keine Templatefunktion

en: %qD is not a type
de: %qD ist kein Typ

en: %qD is not a valid template argument because %qD is a variable, not the address of a variable
de: %qD ist kein gültiges Templateargument, weil %qD eine Variable und nicht die Adresse einer Variable ist

en: %qD is not a variable
de: %qD ist keine Variable

en: %qD is not a variable in clause %<firstprivate%>
de: %qD ist in Klausel %<firstprivate%> keine Variable

en: %qD is not a variable in clause %<lastprivate%>
de: %qD ist in Klausel %<lastprivate%> keine Variable

en: %qD is not a variable in clause %qs
de: %qD ist in Klausel %qs keine Variable

en: %qD is not an enumerator-name
de: %qD ist kein Aufzählungsname

en: %qD is not captured
de: %qD ist nicht aufgefangen

en: %qD is not declared in %qD
de: %qD in %qD nicht deklariert

en: %qD is not defined outside of function scope
de: %qD ist außerhalb des Funktionsgültigkeitsbereiches nicht definiert

en: %qD is static but used in inline function %qD which is not static
de: %qD ist statisch, wird jedoch in Inline-Funktion %qD verwendet, was nicht statisch ist

en: %qD is thread-local and so cannot be dynamically initialized
de: %qD ist Thread-lokal und kann damit nicht dynamisch initialisiert werden

en: %qD is used uninitialized in this function
de: %qD wird in dieser Funktion uninitialisiert verwendet

en: %qD may be used uninitialized in this function
de: %qD könnte in dieser Funktion uninitialisiert verwendet werden

en: %qD may not be declared as static
de: %qD darf nicht als »static« deklariert werden

en: %qD may not be declared within a namespace
de: %qD darf nicht innerhalb eines Namensbereiches definiert werden

en: %qD must be a nonstatic member function
de: %qD muss eine nichtstatische Elementfunktion sein

en: %qD must be either a non-static member function or a non-member function
de: %qD muss entweder eine nichtstatische Elementfunktion oder eine Nicht-Element-Funktion sein

en: %qD must have an argument of class or enumerated type
de: %qD muss ein Argument von einem Klassen- oder Aufzählungstyp haben

en: %qD must not have variable number of arguments
de: »%qD« darf keine variable Argumentanzahl haben

en: %qD must take %<void%>
de: %qD muss %<void%> nehmen

en: %qD must take either one or two arguments
de: »%D« muss entweder ein oder zwei Argumente nehmen

en: %qD must take either zero or one argument
de: %qD muss entweder null oder ein Argument nehmen

en: %qD must take exactly one argument
de: %qD muss genau ein Argument nehmen

en: %qD must take exactly two arguments
de: %qD muss genau zwei Argumente nehmen

en: %qD not declared
de: %qD nicht deklariert

en: %qD not defined
de: %qD nicht definiert

en: %qD redeclared with different access
de: %qD mit anderem Zugriff redeklariert

en: %qD redeclared with different visibility
de: %qD mit anderer Sichtbarkeit redeklariert

en: %qD should be initialized
de: %qD sollte initialisiert werden

en: %qD should be initialized in the member initialization list
de: %qD sollte in Elementinitialisierungsliste initialisiert werden

en: %qD should have been declared inside %qD
de: %qD sollte innerhalb von %qD deklariert werden

en: %qD should never be overloaded
de: %qD sollte niemals überladen werden

en: %qD should return by value
de: %qD sollte Wert zurückgeben

en: %qD used before its definition
de: %qD vor seiner Definition verwendet

en: %qD used in its own initializer
de: %qD in seiner eigenen Initialisierung verwendet

en: %qD used without template parameters
de: %qD ohne Template-Parameter verwendet

en: %qD was declared %<extern%> and later %<static%>
de: %qD wurde %<extern%> deklariert und später %<static%>

en: %qD was declared %qs which implies default visibility
de: %qD wurde als %qs deklariert, was Standardsichtbarkeit bedeutet

en: %qD was declared here
de: %qD wurde hier deklariert

en: %qD was not declared %<constexpr%>
de: %qD wurde nicht als %<constexpr%> definiert

en: %qD was not declared in this scope
de: %qD wurde in diesem Gültigkeitsbereich nicht definiert

en: %qD was not initialized with a constant expression
de: %qD wurde nicht mit konstantem Ausdruck initialisiert

en: %qD was used with no declaration before its definition
de: %qD wurde vor seiner Definition ohne Deklaration verwendet

en: %qD was used with no prototype before its definition
de: %qD wurde vor seiner Definition ohne Prototyp verwendet

en: %qE 2.95 vtable-compatibility attribute applies only to C++ classes
de: %qE 2.95 vtable-Kompatibilitätsattribut trifft nur für C++-Klassen zu

en: %qE 2.95 vtable-compatibility attribute applies only when compiling a kext
de: %qE 2.95 vtable-Kompatibilitätsattribut trifft nur zu, wenn ein »kext« kompiliert wird

en: %qE appears more than once in data clauses
de: %qE tritt in dieser Datenklausel mehrfach auf

en: %qE attribute allows only an integer constant argument
de: Attribut %qE erlaubt nur eine Ganzzahlkonstante als Argument

en: %qE attribute applies only to functions
de: Attribut %qE kann nur auf Funktionen angewandt werden

en: %qE attribute applies only to initialized variables with external linkage
de: Attribut %qE bezieht sich nur auf initialisierte Variablen mit externer Bindung

en: %qE attribute argument not a string constant
de: Argument des Attributs %qE ist keine Zeichenkettenkonstante

en: %qE attribute argument not an integer constant
de: Attributargument %qE ist keine Ganzzahlkonstante

en: %qE attribute argument should be between 0 to 255
de: Argument des Attributs %qE sollte zwischen 0 und 255 sein

en: %qE attribute argument should be between 18 to 255
de: Argument des Attributs %qE sollte zwischen 18 und 255 sein

en: %qE attribute can only be applied to Java class definitions
de: Attribut %qE kann nur auf Java-Klassendefinitionen angewendet werden

en: %qE attribute can only be applied to class definitions
de: Attribut %qE kann nur auf Klassendefinitionen angewendet werden

en: %qE attribute cannot be specified for local variables
de: Attribut %qE kann nicht für lokale Variablen angegeben werden

en: %qE attribute conflicts with attribute %s
de: Attribut %qE steht mit Attribut %s in Konflikt

en: %qE attribute directive ignored
de: Attribut-Anweisung %qE ignoriert

en: %qE attribute does not apply to types
de: Attribut %qE kann nicht auf Typen angewandt werden

en: %qE attribute has no effect
de: Attribut %qE hat keinen Effekt

en: %qE attribute has no effect on unit local functions
de: Attribut %qE wirkt sich nicht auf einheits-lokale Funktionen aus

en: %qE attribute have effect only on public objects
de: Attribut %qE wirkt sich nur auf öffentliche Objekte aus

en: %qE attribute ignored
de: Attribut %qE wird ignoriert

en: %qE attribute ignored because %qT is already defined
de: Attribut %qE ignoriert, da %qT bereits definiert ist

en: %qE attribute ignored for %qE
de: Attribut %qE ignoriert für %qE

en: %qE attribute ignored for field of type %qT
de: Attribut %qE ignoriert für Feld vom Typ %qT

en: %qE attribute ignored on non-class types
de: Attribut %qE ignoriert für Nicht-Klassen-Typen

en: %qE attribute ignored on types
de: Attribut %qE für Typen ignoriert

en: %qE attribute is not supported for R8C target
de: Attribut %qE wird für Ziel R8C nicht unterstützt

en: %qE attribute is not supported on this platform
de: Attribut %qE wird auf dieser Plattform nicht unterstützt

en: %qE attribute is supported only for SH2A
de: Attribut %qE wird nur auf SH2A unterstützt

en: %qE attribute is used for none class-method
de: Attribut %qE wird für für Nicht-Klassen-Methode verwendet

en: %qE attribute only applies to SH2A
de: Attribut %qE gilt nur für SH2A

en: %qE attribute only applies to function types
de: Attribut %qE kann nur auf Funktionstypen angewandt werden

en: %qE attribute only applies to functions
de: Attribut %qE bezieht sich nur auf Funktionen

en: %qE attribute only applies to functions, not %s
de: Attribut %qE gilt nur für Funktionen, nicht %s

en: %qE attribute only applies to interrupt functions
de: Attribut %qE bezieht sich nur auf Interruptfunktionen

en: %qE attribute only applies to variables
de: Attribut %qE bezieht sich nur auf Variablen

en: %qE attribute only applies to variables and functions
de: Attribut %qE gilt nur für Variablen und Funktionen

en: %qE attribute only applies to variadic functions
de: Attribut %qE gilt nur für variadische Funktionen

en: %qE attribute only available for 32-bit
de: Attribut %qE nur für 32 Bit verfügbar

en: %qE attribute only available for 64-bit
de: Attribut %qE nur für 64 Bit verfügbar

en: %qE attribute requires a string constant argument
de: Attribut %qE erfordert eine Zeichenkettenkonstante als Argument

en: %qE attribute requires an integer constant argument
de: Attribut %qE benötigt eine Ganzzahlkonstante als Argument

en: %qE attribute requires prototypes with named arguments
de: Attribut %qE benötigt Prototypen mit benannten Argumenten

en: %qE cannot be used as a function
de: %qE kann nicht als Funktion verwendet werden

en: %qE cannot be used as a member pointer, since it is of type %qT
de: %qE kannt nicht als Elementzeiger verwendet werden, da es vom Typ %qT ist

en: %qE cannot have both %<mips16%> and %<nomips16%> attributes
de: %qE kann nicht gleichzeitig die Attribute %<mips16%> und %<nomips16%> haben

en: %qE declared %<threadprivate%> after first use
de: %qE nach erster Benutzung als %<threadprivate%> deklariert

en: %qE declared as both exported to and imported from a DLL
de: %qE sowohl als »exportiert in« als auch als »importiert aus DLL« deklariert

en: %qE declared as function returning a function
de: %qE als Funktion, die eine Funktion zurückgibt, deklariert

en: %qE declared as function returning an array
de: %qE als Funktion, die ein Feld zurückgibt, deklariert

en: %qE defined as wrong kind of tag
de: %qE als falsche Symbolart definiert

en: %qE does not have class type
de: %qE hat keinen Klassentyp

en: %qE does not name a type
de: %qE bezeichnet keinen Typ

en: %qE fails to be a typedef or built in type
de: %qE ist kein typedef oder eingebauter Typ

en: %qE has both %<extern%> and initializer
de: %qE hat sowohl %<extern%> als auch Initialisierung

en: %qE has invalid type for %<reduction%>
de: %qE hat ungültigen Typ für %<reduction%>

en: %qE has invalid type for %<reduction(%s)%>
de: %qE hat ungültigen Typ für %<reduction(%s)%>

en: %qE has not been declared
de: %qE wurde nicht deklariert

en: %qE has reference type for %qs
de: %qE hat Referenztyp für %qs

en: %qE implies default visibility, but %qD has already been declared with a different visibility
de: %qE impliziert Standardsichtbarkeit, aber %qD wurde bereits mit anderer Sichtbarkeit deklariert

en: %qE in %q#T does not name a type
de: %qE in %q#T benennt keinen Typen

en: %qE in namespace %qE does not name a type
de: %qE in Namensbereich %qE bezeichnet keinen Typ

en: %qE incompatible attribute ignored
de: %qE-inkompatibles Attribut wird ignoriert

en: %qE initialized and declared %<extern%>
de: %qE initialisiert und als %<extern%> deklariert

en: %qE is an unrecognized format function type
de: %qE ist ein nicht erkannter Formatfunktionstyp

en: %qE is deprecated
de: %qE ist veraltet

en: %qE is deprecated (declared at %s:%d)
de: %qE ist veraltet (deklariert bei %s:%d)

en: %qE is deprecated (declared at %s:%d): %s
de: %qE ist veraltet (deklariert bei %s:%d): %s

en: %qE is deprecated: %s
de: %qE ist veraltet: %s

en: %qE is neither function nor member function; cannot be declared friend
de: %qE ist weder eine Funktion noch Elementfunktion; kann nicht als »friend« deklariert werden

en: %qE is not a class or namespace
de: %qE ist keine Klasse oder Namensbereich

en: %qE is not a class, namespace, or enumeration
de: %qE ist keine Klasse, Namensbereich oder Aufzählung

en: %qE is not a constant expression
de: %qE ist kein Konstantenausdruck

en: %qE is not a function name
de: %qE ist kein Funktionsname

en: %qE is not a potential constant expression
de: %qE ist kein potentieller konstanter Ausdruck

en: %qE is not a template
de: %qE ist kein Template

en: %qE is not a type
de: %qE ist kein Typ

en: %qE is not a valid template argument for type %qT
de: %qE ist kein gültiges Templateargument für Typ %qT

en: %qE is not a valid template argument for type %qT because function %qD has not external linkage
de: %qE ist kein gültiges Templateargument für Typ %qT, da die Funktion %qD keine externe Bindung hat

en: %qE is not a valid template argument for type %qT because it is a pointer
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es ein Zeiger ist

en: %qE is not a valid template argument for type %qT because it is not an lvalue
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es kein L-Wert ist

en: %qE is not a valid template argument for type %qT because it is not an object with external linkage
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es kein Objekt mit externer Bindung ist

en: %qE is not a valid template argument for type %qT because it is of type %qT
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es vom Typ %qT ist

en: %qE is not a valid template argument for type %qT because object %qD has not external linkage
de: %qE ist kein gültiges Templateargument für Typ %qT, weil Objekt %qD keine externe Bindung hat

en: %qE is not a valid template argument for type %qT because of conflicts in cv-qualification
de: %qE ist kein gültiges Templateargument für Typ %qT, da es in CV-Qualifikation in Konflikt steht

en: %qE is not a valid template argument for type %qT because string literals can never be used in this context
de: %qE ist kein gültiges Templateargument für Typ %qT, da Zeichenkettensymbole in diesem Zusammenhang nicht verwendet werden können

en: %qE is not a valid template argument of type %qT because %qD does not have external linkage
de: %qE ist kein gültiges Templateargument des Typs %qT, weil %qD keine externe Bindung hat

en: %qE is not a valid template argument of type %qT because %qE is not a variable
de: %qE ist kein gültiges Templateargument für Typ %qT, weil %qE keine Variable ist

en: %qE is not a variable in clause %<firstprivate%>
de: %qE ist in Klausel %<firstprivate%> keine Variable

en: %qE is not a variable in clause %<lastprivate%>
de: %qE ist in Klausel %<lastprivate%> keine Variable

en: %qE is not a variable in clause %qs
de: %qE ist in Klausel %qs keine Variable

en: %qE is not an Objective-C class name or alias
de: %qE ist kein Klassenname oder Alias in Objective-C

en: %qE is not at beginning of declaration
de: %qE ist nicht am Anfang einer Deklaration

en: %qE is not initialized
de: %qE ist nicht initialisiert

en: %qE is not of type %qT
de: %qE ist nicht vom Typ %qT

en: %qE is obsolete; g++ vtables are now COM-compatible by default
de: %qE ist veraltet; g++-vtables sind jetzt standardmäßig COM-verträglich

en: %qE is only allowed in Objective-C dialects
de: %qE ist nur in Objective-C-Dialekten erlaubt

en: %qE is predetermined %qs for %qs
de: %qE ist vorbestimmt %qs für %qs

en: %qE may not respond to %<%c%E%>
de: %qE antwortet möglicherweise nicht auf %<%c%E%>

en: %qE must be %<threadprivate%> for %<copyin%>
de: %qE muss für %<copyin%> %<threadprivate%> sein

en: %qE needs isa option %s
de: %qE erfordert ISA-Option %s

en: %qE needs unknown isa option
de: %qE erfordert unbekannte ISA-Option

en: %qE not specified in enclosing parallel
de: %qE in umgebender Parallele nicht angegeben

en: %qE redeclared as different kind of symbol
de: %qE als andere Symbolart redeklariert

en: %qE redeclared with conflicting %qs attributes
de: %qE mit in Konflikt stehenden Attributen %qs redeklariert

en: %qE refers to a set of overloaded functions
de: %qE verweist auf eine Menge überladener Funktionen

en: %qE undeclared (first use in this function)
de: %qE nicht deklariert (erste Benutzung in dieser Funktion)

en: %qE undeclared here (not in a function)
de: %qE ist hier nicht deklariert (nicht in einer Funktion)

en: %qT and %qT are in disjoint named address spaces
de: %qT und %qT sind in disjunkt benannten Adressräumen

en: %qT declared with greater visibility than its base %qT
de: %qT mit bedeutenderer Sichtbarkeit als seine Basis %qT deklariert

en: %qT declared with greater visibility than the type of its field %qD
de: %qT mit bedeutenderer Sichtbarkeit als der Typ seines Feldes %qD deklariert

en: %qT has a base %qT whose type uses the anonymous namespace
de: %qT hat Basis %qT, dessen Typ den anonymen Namensbereich verwendet

en: %qT has a field %qD whose type uses the anonymous namespace
de: %qT hat ein Feld %qD, dessen Typ den anonymen Namensbereich verwendet

en: %qT has no member named %qE
de: %qT hat kein Element namens %qE

en: %qT has no non-static data member named %qD
de: %qT hat kein nicht-statisches Datenelement namens %qD

en: %qT has virtual bases, default move assignment operator cannot be generated
de: %qT hat virtuelle Basen, Standard-Zuweisungsoperator (move) kann nicht erzeugt werden

en: %qT is a variably modified type
de: %qT ist ein variabel modifizierter Typ

en: %qT is already a friend of %qT
de: %qT ist bereits ein »friend« von %qT

en: %qT is an ambiguous base of %qT
de: %qT ist mehrdeutige Basis von %qT

en: %qT is an inaccessible base of %qT
de: %qT ist eine nicht erreichbare Basis von %qT

en: %qT is not a base of %qT
de: %qT ist keine Basis von %qT

en: %qT is not a class or namespace
de: %qT ist keine Klasse oder Namensbereich

en: %qT is not a class type
de: %qT ist kein Klassentyp

en: %qT is not a class, struct, or union type
de: %qT ist kein Klassen-, Struktur- oder Union-Typ

en: %qT is not a member class template of %qT
de: %qT ist kein Elementklassentemplate von %qT

en: %qT is not a member of %qT
de: %qT ist kein Element von %qT

en: %qT is not a namespace
de: %qT ist kein Namensbereich

en: %qT is not a nested class of %qT
de: %qT ist keine geschachtelte Klasse von %qT

en: %qT is not a pointer-to-object type
de: %qT ist kein Zeiger auf Objekt

en: %qT is not a template
de: %qT ist kein Template

en: %qT is not a template type
de: %qT ist kein Template-Typ

en: %qT is not an accessible base of %qT
de: %qT ist keine erreichbare Basis von %qT

en: %qT is promoted to %qT when passed through %<...%>
de: %qT auf %qT erweitert beim Durchlaufen von %<...%>

en: %qT is/uses anonymous type
de: %qT ist/verwendet anonymen Typen

en: %qT referred to as %qs
de: %qT als %qs verwendet

en: %qT referred to as enum
de: %qT als enum verwendet

en: %qT resolves to %qT, which is is not a class type
de: %qT wird in %qT aufgelöst, was kein Klassentyp ist

en: %qT resolves to %qT, which is not an enumeration type
de: %qT wird in %qT aufgelöst, was kein Aufzählungstyp ist

en: %qV qualifiers cannot be applied to %qT
de: %qV-Qualifizierer können nicht auf %qT angewendet werden

en: %qs appears to be a misspelled interrupt handler
de: %qs scheint ein falsch geschriebener Interrupt-Handler zu sein

en: %qs appears to be a misspelled signal handler
de: %qs scheint ein falsch geschriebener Signal-Handler zu sein

en: %qs attribute ignored
de: Attribut %qs wird ignoriert

en: %qs attribute only applies to functions
de: Attribut %qs gilt nur für Funktionen

en: %qs attribute only applies to variadic functions
de: Attribut %qs gilt nur für variadische Funktionen

en: %qs attribute requires prototypes with named arguments
de: Attribut %qs benötigt Prototypen mit benannten Argumenten

en: %qs can only be specified for functions
de: %qs kann nur für Funktionen angegeben werden

en: %qs cannot appear in a constant-expression
de: %qs kann nicht in einem Konstanten-Ausdruck auftreten

en: %qs combined with %<auto%> qualifier for %qE
de: %qs mit Qualifizierer %<auto%> für %qE kombiniert

en: %qs combined with %<register%> qualifier for %qE
de: %qs mit Qualifizierer %<register%> für %qE kombiniert

en: %qs declared as function returning a function
de: %qs als Funktion, die eine Funktion zurückgibt, deklariert

en: %qs declared as function returning an array
de: %qs als Funktion, die ein Feld zurückgibt, deklariert

en: %qs defined in a non-class scope
de: %qs nicht in Klassen-Gültigkeitsbereich definiert

en: %qs does not support MIPS16 code
de: %qs unterstützt keinen MIPS16-Code

en: %qs expects a constant argument
de: %qs erwartet ein konstantes Argument

en: %qs function uses %<auto%> type specifier without late return type
de: Funktion %qs verwendet Typspezifikation %<auto%> ohne späten Rückgabetypen

en: %qs function with late return type has %qT as its type rather than plain %<auto%>
de: Funktion %qs mit spätem Rückgabetypen hat %qT als seinen Typ statt einfaches %<auto%>

en: %qs function with late return type not declared with %<auto%> type specifier
de: Funktion %qs mit spätem Rückgabetypen nicht mit Typspezifikation %<auto%> deklariert

en: %qs has both %<extern%> and initializer
de: %qs hat sowohl %<extern%> als auch Initialisierung

en: %qs has overflowed
de: %qs übergelaufen

en: %qs initialized and declared %<extern%>
de: %qs initialisiert und als %<extern%> deklariert

en: %qs is an invalid argument to -mcpu=
de: %qs ist ein ungültiges Argument für -mcpu=

en: %qs is an unknown -save-temps option
de: %qs ist eine unbekannte Option für -save-temps

en: %qs is narrower than values of its type
de: %qs ist schmaler als die Werte seines Typs

en: %qs is not a gcov data file
de: %qs ist keine gcov-Datei

en: %qs is not a valid option to the preprocessor
de: %qs ist keine gültige Präprozessoroption

en: %qs is not a valid output file
de: %qs ist keine gültige Ausgabedatei

en: %qs is not available in VLIW functions
de: %qs ist in VLIW-Funktionen nicht verfügbar

en: %qs is not available in non-VLIW functions
de: %qs ist in Nicht-VLIW-Funktionen nicht verfügbar

en: %qs is not valid for %qs
de: %qs ist für %qs ungültig

en: %qs is version %q.*s, expected version %q.*s
de: %qs hat Version %q.*s, Version %q.*s erwartet

en: %qs must be used with %qs
de: %qs muss mit %qs verwendet werden

en: %qs requires a target that provides the %qs instruction
de: %qs erfordert ein Ziel, das den %qs-Befehl unterstützt

en: %qs requires branch-likely instructions
de: %qs erfordert sprungwahrscheinliche Befehle

en: %qs specified for auto variable %qE
de: %qs für »auto«-Variable %qE angegeben

en: %qs specified for parameter %qE
de: %qs für Parameter %qE angegeben

en: %qs specified for structure field
de: %qs für Strukturfeld angegeben

en: %qs specified for structure field %qE
de: %qs für Strukturfeld %qE angegeben

en: %qs specified for unnamed parameter
de: %qs für unbenannten Parameter angegeben

en: %qs tag used in naming %q#T
de: Markierung %qs bei Benennung von %q#T verwendet

en: %qs uses dynamic stack allocation
de: %qs verwendet dynamische Stackanforderung

en: %s %<%s%.*s%> expects a matching %<%T%s%> argument
de: %s %<%s%.*s%> erwartet ein passendes Argument %<%T%s%>

en: %s %<%s%.*s%> expects a matching %<%s%s%> argument
de: %s %<%s%.*s%> erwartet ein passendes Argument %<%s%s%>

en: %s %<%s%.*s%> expects argument of type %<%T%s%>, but argument %d has type %qT
de: %s %<%s%.*s%> erwartet Argumenttyp %<%T%s%>, aber Argument %d hat Typ %qT

en: %s %<%s%.*s%> expects argument of type %<%s%s%>, but argument %d has type %qT
de: %s %<%s%.*s%> erwartet Argumenttyp %<%s%s%>, aber Argument %d hat Typ %qT

en: %s %q+D %s after being referenced with dllimport linkage
de: %s %q+D %s nach Referenzierung mit dllimport-Bindung

en: %s %qE does not fully implement the %qE protocol
de: %s %qE implementiert das %qE-Protokoll nicht vollständig

en: %s '%s'
de: %s: »%s«

en: %s (disable warning using -mno-inefficient-warnings)
de: %s (Warnung kann mit -mno-inefficient-warnings ausgeschaltet werden)

en: %s (program %s)
de: %s (Programm %s)

en: %s REDUCTION variable '%s' must be INTEGER at %L
de: %s REDUCTION-Variable »%s« muss bei %L INTEGER sein

en: %s REDUCTION variable '%s' must be INTEGER or REAL at %L
de: %s REDUCTION-Variable »%s« muss bei %L INTEGER oder REAL sein

en: %s REDUCTION variable '%s' must be LOGICAL at %L
de: %s REDUCTION-Variable »%s« muss bei %L LOGICAL sein

en: %s argument to IMAGE_INDEX must be a rank one array at %L
de: Argument »%s« für IMAGE_INDEX muss Feld mit Rang 1 bei %L sein

en: %s at %L must be INTEGER
de: %s bei %L muss INTEGER sein

en: %s at %L must be a scalar
de: %s bei %L muss skalar sein

en: %s attribute applied to %s %s at %L
de: Attribut %s auf %s %s bei %L angewendet

en: %s attribute at %L is not allowed outside of the specification part of a module
de: Attribut %s bei %L ist außerhalb des Spezifikationsabschnitts eines Moduls nicht erlaubt

en: %s attribute conflicts with %s attribute at %L
de: Attribut %s steht mit Attribut %s bei %L in Konflikt

en: %s attribute conflicts with %s attribute in '%s' at %L
de: Attribut %s steht mit Attribut %s in »%s« bei %L in Konflikt

en: %s attribute not allowed in BLOCK DATA program unit at %L
de: Attribut %s ungültig in BLOCK DATA - Programmeinheit bei %L

en: %s attribute of '%s' conflicts with %s attribute at %L
de: Attribut %s von »%s« steht mit Attribut %s bei %L in Konflikt

en: %s cannot be used in asm here
de: %s kann nicht hier in »asm« verwendet werden

en: %s clause object '%s' has ALLOCATABLE components at %L
de: Klausel %s - Objekt »%s« hat bei %L ALLOCATABLE-Komponenten

en: %s does not support %%n$ operand number formats
de: %s unterstützt nicht %%n$-Operandennummerformate

en: %s does not support %s
de: %s unterstützt nicht %s

en: %s does not support %s with the %<%%%c%> %s format
de: %s unterstützt nicht %s mit dem Format %<%%%c%> %s

en: %s does not support block_ends_with_call_p
de: %s unterstützt nicht block_ends_with_call_p

en: %s does not support block_ends_with_condjump_p
de: %s unterstützt nicht block_ends_with_condjump_p

en: %s does not support can_duplicate_block_p
de: %s unterstützt nicht can_duplicate_block_p

en: %s does not support can_merge_blocks_p
de: %s unterstützt nicht can_merge_blocks_p

en: %s does not support can_remove_branch_p
de: %s unterstützt nicht can_remove_branch_p

en: %s does not support create_basic_block
de: %s unterstützt nicht create_basic_block

en: %s does not support delete_basic_block
de: %s unterstützt nicht delete_basic_block

en: %s does not support duplicate_block
de: %s unterstützt nicht duplicate_block

en: %s does not support flow_call_edges_add
de: %s unterstützt nicht flow_call_edges_add

en: %s does not support make_forwarder_block
de: %s unterstützt nicht make_forwarder_block

en: %s does not support merge_blocks
de: %s unterstützt nicht merge_blocks

en: %s does not support move_block_after
de: %s unterstützt nicht move_block_after

en: %s does not support predict_edge
de: %s unterstützt nicht predict_edge

en: %s does not support predicted_by_p
de: %s unterstützt nicht predicted_by_p

en: %s does not support redirect_edge_and_branch
de: %s unterstützt nicht redirect_edge_and_branch

en: %s does not support redirect_edge_and_branch_force
de: %s unterstützt nicht redirect_edge_and_branch_force

en: %s does not support split_block
de: %s unterstützt nicht split_block

en: %s does not support split_edge
de: %s unterstützt nicht split_edge

en: %s does not support the %<%%%c%> %s format
de: %s unterstützt nicht das Format %<%%%c%> %s

en: %s does not support the %<%%%s%c%> %s format
de: %s unterstützt nicht das Format %<%%%s%c%> %s

en: %s does not support the %qs %s length modifier
de: %s unterstützt nicht den Längenmodifizierer %qs %s

en: %s expects an integer literal in the range [%d, %d]
de: %s erwartet ein Ganzzahlliteral im Bereich [%d, %d]

en: %s expects an integer literal in the range [%d, %d]. (%wd)
de: %s erwartet ein Ganzzahlliteral im Bereich [%d, %d]. (%wd)

en: %s expression list treated as compound expression
de: %s Ausdrucksliste als zusammengesetzten Ausdruck behandelt

en: %s ignored with %s and %<%%%c%> %s format
de: %s ignoriert mit %s und Format %<%%%c%> %s

en: %s ignored with %s in %s format
de: %s ignoriert mit %s im Format %s

en: %s in CFString literal
de: %s in CFString-Literal

en: %s is not INTRINSIC procedure name at %C
de: %s ist kein INTRINSIC-Prozedurname bei %C

en: %s is not supported by this configuration
de: %s wird von dieser Konfiguration nicht unterstützt

en: %s only accepts %d arguments
de: %s akzeptiert nur %d Argumente

en: %s only accepts 1 argument
de: %s akzeptiert nur 1 Argument

en: %s only accepts 2 arguments
de: %s akzeptiert nur 2 Argumente

en: %s procedure at %L is already declared as %s procedure
de: Prozedur %s bei %L ist bereits als Prozedur %s deklariert

en: %s returned %d exit status
de: %s gab Ende-Status %d zurück

en: %s specifier in %s statement at %C has invalid value '%s'
de: Spezifizierer %s in Anweisung %s bei %C hat ungültigen Wert »%s«

en: %s statement at %C cannot follow %s statement at %L
de: Anweisung %s bei %C kann nicht auf Anweisung %s bei %L folgen

en: %s statement at %C cannot terminate a non-block DO loop
de: Anweisung %s bei %C kann keine DO-Schleife ohne Block beenden

en: %s statement at %C follows another accessibility specification
de: Anweisung %s bei %C folgt einer anderen Zugriffsspezifikation

en: %s statement at %C leaving OpenMP structured block
de: Anweisung %s bei %C hinterlässt OpenMP-strukturierten Block

en: %s statement expected at %L
de: %s-Anweisung bei %L erwartet

en: %s statement must appear in a MODULE
de: Anweisung %s muss in einem MODULE auftreten

en: %s statement not allowed in PURE procedure at %C
de: %s-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: %s tag
de: %s Symbol

en: %s tag at %L must be of type %s
de: Markierung %s bei %L muss vom Typ %s sein

en: %s tag at %L must be scalar
de: Markierung %s bei %L muss ein Skalar sein

en: %s tag with INQUIRE
de: %s-Symbol mit INQUIRE

en: %s terminated with signal %d [%s]
de: %s mit Signal %d [%s] beendet

en: %s terminated with signal %d [%s]%s
de: %s mit Signal %d [%s]%s beendet

en: %s terminated with signal %d [%s], core dumped
de: %s mit Signal %d [%s] beendet (Coredump)

en: %s used with %<%%%c%> %s format
de: %s verwendet mit Format %<%%%c%> %s

en: %s variable %qE is private in outer context
de: %s Variable %qE ist im äußeren Kontext »private«

en: %s"%s"%s is invalid
de: %s"%s"%s ist ungültig

en: %s"%s"%s is not allowed
de: %s"%s"%s ist nicht erlaubt

en: %s%#D <deleted>
de: %s%#D <gelöscht>

en: %s%#D <near match>
de: %s%#D <nahe Übereinstimmung>

en: %s%D(%T) <built-in>
de: %s%D(%T) <eingebaut>

en: %s%D(%T, %T) <built-in>
de: %s%D(%T, %T) <eingebaut>

en: %s%D(%T, %T, %T) <built-in>
de: %s%D(%T, %T, %T) <eingebaut>

en: %s%T <conversion>
de: %s%T <Umformung>

en: %s%s%s %sversion %s (%s)
    %s	compiled by GNU C version %s,
de: %s%s%s %sVersion %s (%s)
    %s	kompiliert von GNU-C-Version %s,

en: %s%s%s %sversion %s (%s) compiled by CC,
de: %s%s%s %sVersion %s (%s) kompiliert von CC,

en: %s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
de: %s%sGGC-Heuristik: --param ggc-min-expand=%d --param ggc-min-heapsize=%d

en: %s%swarning: %s header version %s differs from library version %s.
de: %s%sWarnung: %s-Header-Version %s unterscheidet sich von Bibliotheksversion %s.

en: %s-%s is an empty range
de: %s-%s ist ein leerer Bereich

en: %s: %d basic blocks and %d edges/basic block
de: %s: %d Basis-Blöcke und %d Kanten/Basis-Blöcke

en: %s: %d basic blocks and %d registers
de: %s: %d Basis-Blöcke und %d Register

en: %s: %s compiler not installed on this system
de: %s: %s-Compiler ist auf diesem System nicht installiert

en: %s: --param arguments should be of the form NAME=VALUE
de: %s: »--param«-Argumente sollten von der Form NAME=VALUE sein

en: %s: -fcompare-debug failure
de: %s: Fehlschlag von -fcompare-debug

en: %s: -fcompare-debug failure (length)
de: %s: Fehlschlag von -fcompare-debug (Länge)

en: %s: Cannot open output file: %s
de: %s: Ausgabedatei %s konnte nicht geöffnet werden

en: %s: Failed to close output file %s
de: %s: Ausgabedatei %s konnte nicht geschlossen werden

en: %s: Fourth source operand is not a constant
de: %s: Vierter Quelloperand ist keine Konstante

en: %s: In instantiation of %qs:
de: %s: In Instanziierung von %qs:

en: %s: PCH file was invalid
de: %s: PCH-Datei war ungültig

en: %s: Second source operand is not a constant
de: %s: Zweiter Quelloperand ist keine Konstante

en: %s: Third source operand is not a constant
de: %s: Dritter Quelloperand ist keine Konstante

en: %s: all warnings being treated as errors
de: %s: Alle Warnungen werden als Fehler behandelt

en: %s: at least one operand can%'t be handled
de: %s: mindestens ein Operand kann nicht behandelt werden

en: %s: attempt to rename spec %qs to already defined spec %qs
de: %s: Versuch, Spezifikation %qs in bereits definierte Spezifikation %qs umzubenennen

en: %s: cannot open as COFF file
de: %s kann nicht als COFF-Datei geöffnet werden

en: %s: could not determine length of compare-debug file %s
de: %s: Größe der Vergleichs-Prüfdatei %s konnte nicht ermittelt werden

en: %s: could not open compare-debug file %s
de: %s: Vergleichs-Prüfdatei %s konnte nicht geöffnet werden

en: %s: couldn%'t open PCH file: %m
de: %s: PCH-Datei konnte nicht geöffnet werden: %m

en: %s: linker input file unused because linking not done
de: %s: Eingabedateien des Binders unbenutzt, da keine Bindung geschieht

en: %s: not a COFF file
de: %s: keine COFF-Datei

en: %s: some warnings being treated as errors
de: %s: Einige Warnungen werden als Fehler behandelt

en: %s:%d:   [ skipping %d instantiation contexts ]
de: %s:%d:   [ %d Instanziierungskontexte werden übersprungen ]

en: %s:%d:   in constexpr expansion of %qs
de: %s:%d:   in constexpr-Ersetzung von %qs

en: %s:%d:   instantiated from here
de: %s:%d:   instanziiert von hier

en: %s:%d:   recursively instantiated from %qs
de: %s:%d:   rekursiv instanziiert von %qs

en: %s:%d:   recursively instantiated from here
de: %s:%d:   rekursiv instanziiert von hier

en: %s:%d: Illegal preprocessor directive
de: %s:%d: Ungültige Präprozessordirektive

en: %s:%d: Invalid state file;
de: %s:%d: Ungültige Zustandsdatei;

en: %s:%d: Invalid state file; %s
de: %s:%d: Ungültige Zustandsdatei; %s

en: %s:%d: confused by earlier errors, bailing out
de: %s:%d: durch frühere Fehler verwirrt, Abbruch

en: %s:%d: file %s left but not entered
de: %s:%d: Datei %s verlassen, aber nicht betreten

en: %s:%d:%d:   [ skipping %d instantiation contexts ]
de: %s:%d:%d:   [ %d Instanziierungskontexte werden übersprungen ]

en: %s:%d:%d:   in constexpr expansion of %qs
de: %s:%d:%d:   in constexpr-Ersetzung von %qs

en: %s:%d:%d:   instantiated from %qs
de: %s:%d:%d:    instanziiert von %qs

en: %s:%d:%d:   instantiated from here
de: %s:%d:%d:   instanziiert von hier

en: %s:%d:%d:   recursively instantiated from %qs
de: %s:%d:%d:   rekursiv instanziiert von %qs

en: %s:%d:%d:   recursively instantiated from here
de: %s:%d:%d:   rekursiv instanziiert von hier

en: %s:%d:%d: Invalid state file;
de: %s:%d:%d: Ungültige Zustandsdatei;

en: %s:%d:%d: Invalid state file; %s
de: %s:%d:%d: Ungültige Zustandsdatei; %s

en: %s:'%s' has arcs from exit block
de: %s: »%s« hat Bögen vom Eintrittsblock

en: %s:'%s' has arcs to entry block
de: %s: »%s« hat Bögen zum Eintrittsblock

en: %s:'%s' lacks entry and/or exit blocks
de: %s: Eintrag und/oder Exit-Blöcke fehlen in »%s«

en: %s:already seen blocks for '%s'
de: %s: bereits gesehene Blöcke für »%s«

en: %s:cannot open data file, assuming not executed
de: %s: kann nicht geöffnet werden, wird als nicht ausgeführt vermutet

en: %s:cannot open graph file
de: %s: Graphen-Datei kann nicht geöffnet werden

en: %s:cannot open source file
de: %s: Quelldatei kann nicht geöffnet werden

en: %s:corrupted
de: %s: beschädigt

en: %s:could not open output file '%s'
de: %s: Ausgabedatei »%s« konnte nicht geöffnet werden

en: %s:creating '%s'
de: %s: »%s« wird erzeugt

en: %s:error writing output file '%s'
de: %s: Fehler beim Schreiben der Ausgabedatei »%s«

en: %s:graph is unsolvable for '%s'
de: %s: Graph ist für »%s« unlösbar

en: %s:no functions found
de: %s: keine Funktionen gefunden

en: %s:no lines for '%s'
de: %s: keine Zeilen für »%s«

en: %s:not a gcov data file
de: %s: keine gcov-Datei

en: %s:not a gcov graph file
de: %s: keine gcov-Graph-Datei

en: %s:overflowed
de: %s: übergelaufen

en: %s:profile mismatch for '%s'
de: %s: Profil passt nicht für »%s«

en: %s:source file is newer than graph file '%s'
de: %s: Quelldatei ist neuer als Graphen-Datei »%s«

en: %s:stamp mismatch with graph file
de: %s: Marke passt nicht zur Graph-Datei

en: %s:unknown function '%u'
de: %s: unbekannte Funktion »%u«

en: %s:version '%.4s', prefer '%.4s'
de: %s: Version »%.4s«, aber »%.4s« wird bevorzugt

en: %s:version '%.4s', prefer version '%.4s'
de: %s: Version »%.4s«, aber Version »%.4s« wird bevorzugt

en: %salign-functions%s is obsolete, use -falign-functions%s
de: %salign-functions%s ist veraltet, Ersatz: -falign-functions%s

en: %salign-jumps%s is obsolete, use -falign-jumps%s
de: %salign-jumps%s ist veraltet, Ersatz: -falign-jumps%s

en: %salign-loops%s is obsolete, use -falign-loops%s
de: %salign-loops%s ist veraltet, Ersatz: -falign-loops%s

en: %salign-loops=%d%s is not between 0 and %d
de: %salign-loops=%d%s ist nicht zwischen 0 und %d

en: %sbranch-cost=%d%s is not between 0 and 5
de: %sbranch-cost=%d%s ist nicht zwischen 0 und 5

en: %slarge-data-threshold=%d%s is negative
de: %slarge-data-threshold=%d%s ist negativ

en: %spreferred-stack-boundary%s is not supported for this target
de: %spreferred-stack-boundary%s wird für dieses Ziel nicht unterstützt

en: %spreferred-stack-boundary=%d%s is not between %d and %d
de: %spreferred-stack-boundary=%d%s ist nicht zwischen %d und %d

en: %sregparm%s is ignored in 64-bit mode
de: %sregparm%s wird im 64-Bit-Modus ignoriert

en: %sregparm=%d%s is not between 0 and %d
de: %sregparm=%d%s ist nicht zwischen 0 und %d

en: %srtd%s is ignored in 64bit mode
de: %srtd%s wird im 64-Bit-Modus ignoriert

en: %ssseregparm%s used without SSE enabled
de: %ssseregparm%s ohne aktiviertes SSE verwendet

en: %stune=x86-64%s is deprecated; use %stune=k8%s or %stune=generic%s instead as appropriate
de: %stune=x86-64%s ist veraltet; stattdessen entsprechend %stune=k8%s oder %stune=generic%s verwenden

en: '
de: «

en: ' ' flag
de: » «-Kennzeichen

en: '!' flag
de: »!«-Kennzeichen

en: '#' flag
de: »#«-Kennzeichen

en: '%%%c' is not a valid operand prefix
de: »%%%c« ist kein gültiger Operandenpräfix

en: '%%&' used without any local dynamic TLS references
de: »%%&« ohne lokale dynamische TLS-Referenzen verwendet

en: '%%l' operand isn't a label
de: »%%l«-Operand ist keine Marke

en: '%s + %s' at %L must be less than or equal to BIT_SIZE('%s')
de: '%s + %s' bei %L muss kleiner oder gleich BIT_SIZE('%s') sein

en: '%s' already defined as specific binding for the generic '%s' at %C
de: »%s« bereits als spezifische Bindung für das allgemeine »%s« bei %C definiert

en: '%s' and '%s' arguments of '%s' intrinsic at %L must have identical shape.
de: Argumente »%s« und »%s« des intrinsischen »%s« bei %L müssen gleiche Form haben.

en: '%s' and '%s' arguments of '%s' intrinsic at %L must have the same type
de: Argumente »%s« und »%s« des intrinsischen »%s« bei %L müssen den selben Typ haben

en: '%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)
de: Argument »%s« des intrinsischen »%s« bei %L kann nicht INTENT(IN) sein

en: '%s' argument of '%s' intrinsic at %L has invalid permutation of dimensions (dimension '%d' duplicated)
de: Argument »%s« des intrinsischen »%s« bei %L hat ungültige Permutation der Dimensionen (Dimension »%d« doppelt)

en: '%s' argument of '%s' intrinsic at %L has invalid shape in dimension %d (%ld/%ld)
de: Argument »%s« des intrinsischen »%s« bei %L hat ungültige Form in Dimension %d (%ld/%ld)

en: '%s' argument of '%s' intrinsic at %L has negative element (%d)
de: Argument »%s« des intrinsischen »%s« bei %L hat negatives Element (%d)

en: '%s' argument of '%s' intrinsic at %L has out-of-range dimension (%d)
de: Argument »%s« des intrinsischen »%s« bei %L hat Dimension außerhalb des Wertebereiches (%d)

en: '%s' argument of '%s' intrinsic at %L has wrong number of elements (%d/%d)
de: Argument »%s« des intrinsischen »%s« bei %L hat falsche Anzahl der Elemente (%d/%d)

en: '%s' argument of '%s' intrinsic at %L is empty
de: Argument »%s« des intrinsischen »%s« bei %L ist leer

en: '%s' argument of '%s' intrinsic at %L is not a valid dimension index
de: Argument »%s« des intrinsischen »%s« bei %L ist kein gültiger Dimensionsindex

en: '%s' argument of '%s' intrinsic at %L must be %s
de: Argument »%s« des intrinsischen »%s« bei %L muss %s sein

en: '%s' argument of '%s' intrinsic at %L must be ALLOCATABLE
de: Argument »%s« des intrinsischen »%s« bei %L muss ALLOCATABLE sein

en: '%s' argument of '%s' intrinsic at %L must be INTEGER
de: Argument »%s« des intrinsischen »%s« bei %L muss ein INTEGER sein

en: '%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL
de: Argument »%s« für intrinsisches »%s« bei %L muss INTEGER oder LOGICAL sein

en: '%s' argument of '%s' intrinsic at %L must be INTEGER or PROCEDURE
de: Argument »%s« für intrinsisches »%s« bei %L muss INTEGER oder PROCEDURE sein

en: '%s' argument of '%s' intrinsic at %L must be INTEGER or REAL
de: Argument »%s« des intrinsischen »%s« bei %L muss INTEGER oder REAL sein

en: '%s' argument of '%s' intrinsic at %L must be REAL or COMPLEX
de: Argument »%s« des intrinsischen »%s« bei %L muss REAL oder COMPLEX sein

en: '%s' argument of '%s' intrinsic at %L must be a POINTER
de: Argument »%s« des intrinsischen »%s« bei %L muss ein POINTER sein

en: '%s' argument of '%s' intrinsic at %L must be a POINTER or a TARGET
de: Argument »%s« des intrinsischen »%s« bei %L muss ein POINTER oder ein TARGET sein

en: '%s' argument of '%s' intrinsic at %L must be a constant
de: Argument »%s« des intrinsischen »%s« bei %L muss eine Konstante sein

en: '%s' argument of '%s' intrinsic at %L must be a logical array
de: Argument »%s« des intrinsischen »%s« bei %L muss ein logisches Feld sein

en: '%s' argument of '%s' intrinsic at %L must be a non-derived type
de: Argument »%s« des intrinsischen »%s« bei %L darf kein abgeleiteter Typ sein

en: '%s' argument of '%s' intrinsic at %L must be a numeric type
de: Argument »%s« des intrinsischen »%s« bei %L muss ein numerischer Typ sein

en: '%s' argument of '%s' intrinsic at %L must be a pointer or target VARIABLE or FUNCTION
de: Argument »%s« des intrinsischen »%s« bei %L muss ein Zeiger oder Ziel VARIABLE oder FUNCTION sein

en: '%s' argument of '%s' intrinsic at %L must be a scalar
de: Argument »%s« des intrinsischen »%s« bei %L muss ein Skalar sein

en: '%s' argument of '%s' intrinsic at %L must be a variable
de: Argument »%s« des intrinsischen »%s« bei %L muss eine Variable sein

en: '%s' argument of '%s' intrinsic at %L must be an array
de: Argument »%s« des intrinsischen »%s« bei %L muss ein Feld sein

en: '%s' argument of '%s' intrinsic at %L must be be an interoperable data entity
de: Argument »%s« des intrinsischen »%s« bei %L muss kompatible Datenentität sein

en: '%s' argument of '%s' intrinsic at %L must be default real
de: Argument »%s« des intrinsischen »%s« bei %L muss ein Standard-Real sein

en: '%s' argument of '%s' intrinsic at %L must be double precision
de: Argument »%s« des intrinsischen »%s« bei %L muss doppelte Genauigkeit haben

en: '%s' argument of '%s' intrinsic at %L must be less than rank %d
de: Argument »%s« für intrinsisches »%s« bei %L muss geringer als Rang %d sein

en: '%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL
de: Argument »%s« des intrinsischen »%s« bei %L muss numerisch oder LOGICAL sein

en: '%s' argument of '%s' intrinsic at %L must be of a derived type
de: Argument »%s« des intrinsischen »%s« bei %L muss abgeleiteten Typ haben

en: '%s' argument of '%s' intrinsic at %L must be of a dummy variable
de: Argument »%s« des intrinsischen »%s« bei %L muss eine Scheinvariable sein

en: '%s' argument of '%s' intrinsic at %L must be of a kind not wider than the default kind (%d)
de: Argument »%s« des intrinsischen »%s« bei %L darf von der Art nicht breiter als der Stardard (%d) sein

en: '%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable
de: Argument »%s« des intrinsischen »%s« bei %L muss eine OPTIONALe Scheinvariable sein

en: '%s' argument of '%s' intrinsic at %L must be of an extensible type
de: Argument »%s« des intrinsischen »%s« bei %L muss erweiterbaren Typ haben

en: '%s' argument of '%s' intrinsic at %L must be of kind %d
de: Argument »%s« des intrinsischen »%s« bei %L muss von der Art %d sein

en: '%s' argument of '%s' intrinsic at %L must be of rank %d
de: Argument »%s« des intrinsischen »%s« bei %L muss vom Rang %d sein

en: '%s' argument of '%s' intrinsic at %L must be of rank 1 or 2
de: Argument »%s« des intrinsischen »%s« bei %L muss vom Rang 1 oder 2 sein

en: '%s' argument of '%s' intrinsic at %L must be the same kind as '%s'
de: Argument »%s« des intrinsischen »%s« bei %L muss von der selben Art wie »%s« sein

en: '%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'
de: Argument »%s« des intrinsischen »%s« bei %L muss vom gleichen Typ und gleicher Art wie »%s« sein

en: '%s' argument of '%s' intrinsic at %L must have a type of either REAL or INTEGER
de: »%s« Argument des intrinsischen »%s« bei %L muss vom Typ REAL oder INTEGER sein

en: '%s' argument of '%s' intrinsic at %L must have the same rank as '%s' or be a scalar
de: Argument »%s« des intrinsischen »%s« bei %L muss den selben Rang wie »%s« haben oder skalar sein

en: '%s' argument of '%s' intrinsic at %L must not be OPTIONAL
de: Argument »%s« des intrinsischen »%s« bei %L darf nicht OPTIONAL sein

en: '%s' argument of '%s' intrinsic at %L must not be a subobject of '%s'
de: Argument »%s« des intrinsischen »%s« bei %L darf kein Unterobjekt von »%s« sein

en: '%s' argument of '%s' intrinsic at %L must not be present if 'x' is COMPLEX
de: Argument »%s« des intrinsischen »%s« bei %L darf nicht vorhanden sein, wenn »x« COMPLEX ist

en: '%s' argument of '%s' intrinsic at %L must provide at least as many elements as there are .TRUE. values in '%s' (%ld/%d)
de: Argument »%s« des intrinsischen »%s« bei %L muss mindestens so viele Elemente haben wie es .TRUE.-Werte »%s« (%ld/%d) gibt

en: '%s' argument of intrinsic '%s' at %L of must have rank %d or be a scalar
de: Argument »%s« des intrinsischen »%s« bei %L muss Rang %d haben oder ein Skalar sein

en: '%s' at %C is not a member of the '%s' structure
de: »%s« bei %C ist kein Element der Struktur »%s«

en: '%s' at %C is not a variable
de: »%s« bei %C ist keine Variable

en: '%s' at %C is the name of a recursive function and so refers to the result variable. Use an explicit RESULT variable for direct recursion (12.5.2.1)
de: »%s« bei %C ist der Name einer rekursiven Funktion und verweist damit auf die Ergebnisvariable. Für direkte Rekursion, eine explizite RESULT-Variable verwenden (12.5.2.1)

en: '%s' at %L already is initialized at %L
de: »%s« bei %L wurde bereits bei %L initialisiert

en: '%s' at %L cannot have the VALUE attribute because it is not a dummy argument
de: »%s« bei %L kann nicht das VALUE-Attribut haben, da es kein Scheinargument ist

en: '%s' at %L has a type, which is not consistent with the CALL at %L
de: »%s« bei %L hat einen Typen, der nicht zum CALL bei %L passt

en: '%s' at %L has attributes specified outside its INTERFACE body
de: »%s« bei %L hat außerhalb seines INTERFACE-Körpers spezifizierte Attribute

en: '%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape array
de: »%s« bei %L hat Attribut CONTIGUOUS, aber ist kein Feldzeiger oder Feld vermuteter Größe

en: '%s' at %L is ambiguous
de: »%s« bei %L ist mehrdeutig

en: '%s' at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (12.4.1.5)
de: »%s« bei %L ist ein Feld und optional; wenn es fehlt, kann es nicht das effektive Argument einer elementaren Prozedur sein, es sei denn, es gibt ein nicht-optionales Argument mit dem selben Rang (12.4.1.5)

en: '%s' at %L is not a VALUE
de: '%s' bei %L ist kein WERT

en: '%s' at %L is not a function
de: »%s« bei %L ist keine Funktion

en: '%s' at %L is not a module procedure
de: »%s« bei %L ist keine Modulprozedur

en: '%s' at %L must be less than BIT_SIZE('%s')
de: '%s' bei %L muss kleiner als BIT_SIZE('%s') sein

en: '%s' at %L must be less than or equal to BIT_SIZE('%s')
de: '%s' bei %L muss kleiner oder gleich BIT_SIZE('%s') sein

en: '%s' at %L must be less than or equal to the BIT_SIZE of INTEGER(KIND=%d)
de: '%s' bei %L muss kleiner oder gleich der BIT_SIZE von INTEGER(KIND=%d) sein

en: '%s' at %L must be nonnegative
de: '%s' bei %L muss nichtnegativ sein

en: '%s' at %L must have constant character length in this context
de: »%s« bei %L muss in diesem Zusammenhang konstante Zeichenlänge haben

en: '%s' cannot be extended at %C because it is BIND(C)
de: »%s« kann bei %C nicht erweitert werden, da es BIND(C) ist

en: '%s' cannot be extended at %C because it is a SEQUENCE type
de: »%s« kann bei %C nicht erweitert werden, da es ein SEQUENCE-Typ ist

en: '%s' in EXTENDS expression at %C is not a derived type
de: »%s« in EXTENDS-Ausdruck bei %C ist kein abgeleiteter Typ

en: '%s' in the pointer assignment at %L cannot be an l-value since it is a procedure
de: »%s« in Zeigerzuweisung bei %L kann kein L-Wert sein, da es eine Prozedur ist

en: '%s' is already IMPORTed from host scoping unit at %C.
de: »%s« bereits aus Host-Sichtbarkeitseinheit bei %C IMPORTiert.

en: '%s' of '%s' is PRIVATE at %L
de: »%s« von »%s« ist bei %L PRIVATE

en: '%s' was assigned to '%s', but was not defined during recompilation, or vice versa
de: »%s« wurde an »%s« zugewiesen, war aber nicht während Rekompilierung definiert, oder umgekehrt

en: '&' not allowed by itself in line %d
de: »&« ist in Zeile %d selbst nicht erlaubt

en: ''' flag
de: »'«-Kennzeichen

en: '(' flag
de: »(«-Kennzeichen

en: ')' expected at %C
de: »)« bei %C erwartet

en: '+' flag
de: »+«-Kennzeichen

en: '-' flag
de: »-«-Kennzeichen

en: '-fd-lines-as-code' has no effect in free form
de: »-fd-lines-as-code« hat keine Auswirkung in Freiform

en: '-fd-lines-as-comments' has no effect in free form
de: »-fd-lines-as-comments« hat keine Auswirkung in Freiform

en: '0' flag
de: »0«-Kennzeichen

en: '::' needed in PROCEDURE binding with explicit target at %C
de: »::« in PROCEDURE-Bindung mit explizitem Ziel bei %C erforderlich

en: '=> target' is invalid for DEFERRED binding at %C
de: »=> target« ist ungültig für DEFERRED-Bindung bei %C

en: 'B' operand has multiple bits set
de: »B«-Operand hat mehrere gesetzte Bits

en: 'B' operand is not constant
de: »B«-Operand ist nicht konstant

en: 'E' modifier
de: »E«-Modifizierer

en: 'I' flag
de: »I«-Kennzeichen

en: 'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s
de: Argument »MOLD« des intrinsischen »TRANSFER« bei %L darf nicht %s sein

en: 'O' modifier
de: »O«-Modifizierer

en: '^' flag
de: »^«-Kennzeichen

en: '_' flag
de: »_«-Kennzeichen

en: 'a%d' argument of '%s' intrinsic at %L must be %s(%d)
de: Argument »a%d« des intrinsischen »%s« bei %L muss %s(%d) sein

en: 'a' flag
de: »a«-Kennzeichen

en: 'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER
de: Argument »a1« des intrinsischen »%s« bei %L muss INTEGER, REAL oder CHARACTER sein

en: 'assign' property %qs is using bit-field instance variable %qs
de: »assign«-Eigenschaft %qs verwendet Bitfeld-Instanzvariable %qs

en: 'atomic' property %qs is using bit-field instance variable %qs
de: »atomic«-Eigenschaft %qs verwendet Bitfeld-Instanzvariable %qs

en: 'dim' argument of %s intrinsic at %L is not a valid dimension index
de: Argument »dim« des intrinsischen »%s« bei %L ist kein gültiger Dimensionsindex

en: 'dim' argument of '%s' intrinsic at %L is not a valid codimension index
de: Argument »dim« des intrinsischen »%s« bei %L ist kein gültiger Codimensionsindex

en: 'dim' argument of '%s' intrinsic at %L is not a valid dimension index
de: Argument »dim« des intrinsischen »%s« bei %L ist kein gültiger Dimensionsindex

en: 'm' flag
de: »m«-Kennzeichen

en: 'o' operand is not constant
de: »o«-Operand ist nicht konstant

en: 'q' flag
de: »q«-Kennzeichen

en: 'shape' argument of 'reshape' intrinsic at %L has more than %d elements
de: Argument »shape« des intrinsischen »reshape« bei %L hat mehr als %d Elemente

en: 'shape' argument of 'reshape' intrinsic at %L must be an array of constant size
de: Argument »shape« des intrinsischen »reshape« bei %L muss ein Feld konstanter Größe sein

en: 'source' argument of 'shape' intrinsic at %L must not be an assumed size array
de: Argument »source« des intrinsischen »shape« bei %L darf kein Feld impliziter Größe sein

en: (Messages without a matching method signature
de: (Nachrichten ohne passende Methodensignatur

en: (a pointer to member can only be formed with %<&%E%>)
de: (ein Zeiger auf ein Element kann nur mit %<»&%E%> erzeugt werden)

en: (an out of class initialization is required)
de: (eine Initialisierung außerhalb der Klasse ist erforderlich)

en: (anonymous)
de: (anonym)

en: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here)
de: (wenn das nicht beabsichtigt war, sollte sicher gestellt werden, dass das Funktions-Template bereits deklariert wurde, und <> hier hinter Funktionsnamen eingefügt wurde)

en: (if you use %<-fpermissive%> G++ will accept your code)
de: (G++ wird den Code mit »-fpermissive« akzeptieren)

en: (if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)
de: (mit %<-fpermissive%> wird G++ den Code akzeptieren, aber die Verwendung eines nicht deklarierten Namens ist veraltet)

en: (near initialization for %qs)
de: (nahe der Initialisierung für %qs)

en: (perhaps %<typename %T::%E%> was intended)
de: (vielleicht war %<typename %T::%E%> beabsichtigt)

en: (perhaps a semicolon is missing after the definition of %qT)
de: (vielleicht fehlt ein Semikolon hinter der Definition von %qT)

en: (perhaps the %<offsetof%> macro was used incorrectly)
de: (vielleicht wurde das Makro %<offsetof%> falsch verwendet)

en: (so you should pass %qT not %qT to %<va_arg%>)
de: (Es sollte also %qT statt %qT an %<va_arg%> übergeben werden)

en: (static destructors for %s)
de: (statische Destruktoren für %s)

en: (static initializers for %s)
de: (statische Initialisierungen für %s)

en: (the message is only displayed one per source file)
de: (die Meldung wird für jede Quelldatei nur einmal angezeigt)

en: ({anonymous})
de: ({anonym})

en: *** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.
de: *** WARNUNG *** es gibt aktive Plugins - bitte keine Fehler melden, wenn diese nicht ohne Plugins reproduziert werden können.

en: --CLASSPATH	Deprecated; use --classpath instead
de: --CLASSPATH	Veraltet; stattdessen --classpath verwenden

en: --bootclasspath=<path>	Replace system path
de: --bootclasspath=<Pfad>	Systempfad ersetzen

en: --classpath=<path>	Set class path
de: --classpath=<Pfad>	Klassensuchpfad setzen

en: --encoding=<encoding>	Choose input encoding (defaults from your locale)
de: --encoding=<Kodierung>	Eingabekodierung auswählen (Standard: aktuelle Locale)

en: --extdirs=<path>	Set the extension directory path
de: --extdirs=<Pfad>	Den Pfad für das Erweiterungsverzeichnis setzen

en: --help argument %q.*s is ambiguous, please be more specific
de: Argument %q.*s für --help ist mehrdeutig, bitte präzisieren

en: --help=<class>	Display descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params
de: --help=<Klasse>	Beschreibungen für eine bestimmte Klasse von Optionen anzeigen. <Klasse> ist ein oder mehrere Elemente aus optimizers, target, warnings, undocumented, param

en: --param <param>=<value>	Set parameter <param> to value.  See below for a complete list of parameters
de: --param <Param>=<Wert>	Parameter <Param> auf <Wert> setzen. Siehe unten für komplette Parameterliste

en: --param inline-unit-growth limit reached
de: --param inline-unit-growth: Limit erreicht

en: --param large-function-growth limit reached
de: --param large-function-growth: Limit erreicht

en: --param large-stack-frame-growth limit reached
de: --param large-stack-frame-growth: Limit erreicht

en: --param max-inline-insns-auto limit reached
de: --param max-inline-insns-auto: Limit erreicht

en: --param max-inline-insns-single limit reached
de: --param max-inline-insns-single: Limit erreicht

en: --resource requires -o
de: --resource erfordert -o

en: -A<question>=<answer>	Assert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>
de: -A<Frage>=<Antwort>	Die <Antwort> auf eine <Frage> annehmen. Angabe von »-« vor <Frage> schaltet die <Antwort> auf <Frage> aus

en: -D<macro>[=<val>]	Define a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1
de: -D<Makro>[=<Wert>]	Ein <Makro> mit <Wert> definieren. Wenn nur <Makro> angegeben wird, wird <Wert> auf 1 gesetzt

en: -E or -x required when input is from standard input
de: -E oder -x benötigt, wenn die Eingabe von der Standardeingabe kommt

en: -F <dir>	Add <dir> to the end of the main framework include path
de: -F <Verz>	<Verz> an das Ende des Einfügepfades des Haupt-Frameworks anfügen

en: -G<number>	Put global and static data smaller than <number> bytes into a special section (on some targets)
de: -G<Anzahl>	Globale und statische Daten kleiner als <Anzahl> Bytes in einen gesonderten Abschnitt legen (bei manchen Zielarchitekturen)

en: -I <dir>	Add <dir> to the end of the main include path
de: -I <Verz>	<Verz> an das Ende des Haupteinfügepfades anfügen

en: -I- specified twice
de: -I- doppelt angegeben

en: -J<directory>	Put MODULE files in 'directory'
de: -J<Verzeichnis>	MODULE-Dateien in »Verzeichnis« ablegen

en: -MF <file>	Write dependency output to the given file
de: -MF <file>	Abhängigkeiten-Ausgabe in angegebene Datei schreiben

en: -MG may only be used with -M or -MM
de: -MG darf nur mit -M oder -MM verwendet werden

en: -MQ <target>	Add a MAKE-quoted target
de: -MQ <target>	MAKE-zitiertes Ziel hinzufügen

en: -MT <target>	Add an unquoted target
de: -MT <target>	Ein Ziel ohne Anführungszeichen hinzufügen

en: -O<number>	Set optimization level to <number>
de: -O<Zahl>	Optimierungsstufe auf <Zahl> setzen

en: -U<macro>	Undefine <macro>
de: -U<Makro>	<Makro> undefinieren

en: -Werror=%s: no option -%s
de: -Werror=%s: Keine Option -%s

en: -Wformat-contains-nul ignored without -Wformat
de: -Wformat-contains-nul wird ohne -Wformat ignoriert

en: -Wformat-extra-args ignored without -Wformat
de: -Wformat-extra-args wird ohne -Wformat ignoriert

en: -Wformat-nonliteral ignored without -Wformat
de: -Wformat-nonliteral wird ohne -Wformat ignoriert

en: -Wformat-security ignored without -Wformat
de: -Wformat-security wird ohne -Wformat ignoriert

en: -Wformat-y2k ignored without -Wformat
de: -Wformat-y2k wird ohne -Wformat ignoriert

en: -Wformat-zero-length ignored without -Wformat
de: -Wformat-zero-length wird ohne -Wformat ignoriert

en: -Wframe-larger-than=<number>	Warn if a function's stack frame requires more than <number> bytes
de: -Wframe-larger-than=<Anzahl>	Warnen, wenn der Stapelrahmen einer Funktion mehr als <Anzahl> Bytes benötigt

en: -Wlarger-than=<number>	Warn if an object is larger than <number> bytes
de: -Wlarger-than=<Anzahl>	Warnen, wenn ein Objekt größer als <Anzahl> Bytes ist

en: -Wnormalized=<id|nfc|nfkc>	Warn about non-normalised Unicode strings
de: -Wnormalized=<id|nfc|nfkc>	Bei nicht-normalisierten Unicode-Zeichenketten warnen

en: -Xbind-now and -Xbind-lazy are incompatible
de: -Xbind-now und -Xbind-lazy sind unverträglich

en: -aux-info <file>	Emit declaration information into <file>
de: -aux-info <Datei>	Deklarationsinformationen in <Datei> ausgeben

en: -bundle not allowed with -dynamiclib
de: -bundle ist nicht mit -dynamiclib erlaubt

en: -bundle_loader not allowed with -dynamiclib
de: -bundle_loader ist nicht mit -dynamiclib erlaubt

en: -c or -S required for Ada
de: Für Ada wird -c oder -S benötigt

en: -client_name not allowed with -dynamiclib
de: -client_name ist nicht mit -dynamiclib erlaubt

en: -current_version only allowed with -dynamiclib
de: -current_version ist nur mit -dynamiclib erlaubt

en: -d<letters>	Enable dumps from specific passes of the compiler
de: -d<Buchstaben>	Ausgaben von bestimmten Durchläufen des Kompilers einschalten

en: -dumpbase <file>	Set the file basename to be used for dumps
de: -dumpbase <Datei>	Den Basis-Dateinamen für Ausgaben setzen

en: -dumpdir <dir>	Set the directory name to be used for dumps
de: -dumpdir <verzeichnis>	Den Basis-verzeichnisnamen für Ausgaben setzen

en: -f%s and -msdata=%s are incompatible
de: -f%s und -msdata=%s sind unverträglich

en: -f%s ignored for 68HC11/68HC12 (not supported)
de: -f%s für 68HC11/68HC12 ignoriert (nicht unterstützt)

en: -f%s ignored for Unicos/Mk (not supported)
de: -f%s für Unicos/Mk ignoriert (nicht unterstützt)

en: -f%s ignored for target (all code is position independent)
de: -f%s für Ziel ignoriert (der gesamte Code ist positionsunabhängig)

en: -f%s is not supported with CONST16 instructions
de: -f%s wird mit CONST16-Befehlen nicht unterstützt

en: -f%s not supported: ignored
de: -f%s nicht unterstützt: ignoriert

en: -f%sleading-underscore not supported on this target machine
de: -f%sleading-underscore wird auf dieser Zielmaschine nicht unterstützt

en: -fPIC and -fpic are not supported for this target
de: -fPIC und -fpic werden für dieses Ziel nicht unterstützt

en: -fPIC and -fpic are not supported in this configuration
de: -fPIC und -fpic werden in dieser Konfiguration nicht unterstützt

en: -fPIC and -mcall-%s are incompatible
de: -fPIC und -mcall-%s sind unverträglich

en: -fPIC ignored for target (all code is position independent)
de: -fPIC für Ziel ignoriert (der gesamte Code ist positionsunabhängig)

en: -fPIC is not supported
de: -fPIC wird nicht unterstützt

en: -fabi-version=4 (or =0) avoids this error with a change in vector mangling
de: -fabi-version=4 (oder =0) verhindert diesen Fehler mit einer Änderung in Vektorvernichtung

en: -falign-labels=%d is not supported
de: -falign-labels=%d wird nicht unterstützt

en: -falign-loops=%d is not supported
de: -falign-loops=%d wird nicht unterstützt

en: -fassociative-math disabled; other options take precedence
de: -fassociative-math abgeschaltet; andere Optionen haben Vorrang

en: -fblas-matmul-limit=<n>	Size of the smallest matrix for which matmul will use BLAS
de: -fblas-matmul-limit=<n>	Größe der kleinsten Matrix, für die matmul BLAS verwenden wird

en: -fcall-saved-<register>	Mark <register> as being preserved across functions
de: -fcall-saved-<Register>	<Register> als über Funktionsgrenzen hinweg reserviert markieren

en: -fcall-used-<register>	Mark <register> as being corrupted by function calls
de: -fcall-used-<Register>	<Register> als durch Funktionsaufrufe beschädigt markieren

en: -fcheck=[...]	Specify which runtime checks are to be performed
de: -fcheck=[...]	Durchgeführte Laufzeitprüfungen

en: -fcoarray=[...]	Specify which coarray parallelization should be used
de: -fcoarray=[...]	Verwendete Nebenfeld-Parallelisierung angeben

en: -fcompare-debug[=<opts>]	Compile with and without e.g. -gtoggle, and compare the final-insns dump
de: -fcompare-debug[=<Optionen>]	Mit und ohne z.B. -gtoggle kompilieren, und den Dump der finalen Anweisungen vergleichen

en: -fconst-string-class=<name>	Use class <name> for constant strings
de: -fconst-string-class=<Name>	Klasse <Name> für konstante Zeichenketten verwenden

en: -fconstexpr-depth=<number>	Specify maximum constexpr recursion depth
de: -fconstexpr-depth=<Zahl>	Größte Rekursionstiefe für konstante Ausdrücke angeben

en: -fdata-sections not supported for this target
de: -fdata-sections wird für dieses Ziel nicht unterstützt

en: -fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]	Set the debug counter limit.
de: -fdbg-cnt=<Zähler>:<Grenze>[,<Zähler>:<Grenze>,...]	Grenze des Fehlersuchzählers setzen.

en: -fdiagnostics-show-location=[once|every-line]	How often to emit source location at the beginning of line-wrapped diagnostics
de: -fdiagnostics-show-location=[once|every-line]	Wie oft soll Stelle im Quelltext beim Anfang von zeilenumgebrochener Diagnose ausgegeben werden

en: -fdirectives-only is incompatible with -Wunused_macros
de: -fdirectives-only ist mit -Wunused_macros unverträglich

en: -fdirectives-only is incompatible with -traditional
de: -fdirectives-only ist mit -traditional unverträglich

en: -fdump-<type>	Dump various compiler internals to a file
de: -fdump-<type>	Verschiedene compilerinterne Informationen in eine Datei abziehen

en: -fdump-final-insns=filename	Dump to filename the insns at the end of translation
de: -fdump-final-insns=<Datei>	Die Befehle am Ende der Übersetzung in Datei abziehen

en: -fdump-go-spec=filename	Write all declarations to file as Go code
de: -fdump-go-spec=<Datei>	Alle Deklarationen als Go-Code in <Datei> schreiben

en: -femit-class-file should used along with -fsyntax-only
de: -femit-class-file sollte zusammen mit -fsyntax-only verwendet werden

en: -femit-struct-debug-baseonly	Aggressive reduced debug info for structs
de: -femit-struct-debug-baseonly	Aggressiv reduzierte Debuginfo für Strukturen

en: -femit-struct-debug-detailed=<spec-list>	Detailed reduced debug info for structs
de: -femit-struct-debug-detailed=<spec-list>Ausführliche reduzierte Debuginfo für Strukturen

en: -femit-struct-debug-reduced	Conservative reduced debug info for structs
de: -femit-struct-debug-reduced	Konservativ reduzierte Debuginfo für Strukturen

en: -fexcess-precision=[fast|standard]	Specify handling of excess floating-point precision
de: -fexcess-precision=[fast|standard]	Behandlung überschüssiger Gleitkommagenauigkeit bestimmen

en: -fexec-charset=<cset>	Convert all strings and character constants to character set <cset>
de: -fexec-charset=<Zeichensatz>	Alle Zeichenketten und Zeichenkonstanten in <Zeichensatz> umwandeln

en: -ffixed-<register>	Mark <register> as being unavailable to the compiler
de: -ffixed-<Register>	<Register> als für den Compiler nicht verfügbar markieren

en: -ffixed-line-length-<n>	Use n as character line width in fixed mode
de: -ffixed-line-length-<n>	Im festen Modus n als Zeilenlänge verwenden

en: -ffpe-trap=[...]	Stop on following floating point exceptions
de: -ffpe-trap=[...]	Bei folgenden Gleitkommaausnahmen anhalten

en: -ffree-line-length-<n>	Use n as character line width in free mode
de: -ffixed-line-length-<n>	Im freien Modus n als Zeilenlänge verwenden

en: -ffunction-sections disabled; it makes profiling impossible
de: -ffunction-sections ausgeschaltet; das macht Profiling unmöglich

en: -ffunction-sections not supported for this target
de: -ffunction-sections wird für dieses Ziel nicht unterstützt

en: -fgo-dump-<type>	Dump Go frontend internal information
de: -fgo-dump-<Typ>	Interne Information des Go-Frontends in Datei ausgeben

en: -fgo-prefix=<string>	Set package-specific prefix for exported Go names
de: -fgo-prefix=<Zeichenkette>	Setzt den paketspezifischen Präfix für exportierte Go-Namen

en: -fhandle-exceptions has been renamed -fexceptions (and is now on by default)
de: -fhandle-exceptions wurde in -fexceptions umbenannt (und ist nun voreingestellt)

en: -findirect-dispatch is incompatible with -freduced-reflection
de: -findirect-dispatch ist mit -freduced-reflection unverträglich

en: -finit-character=<n>	Initialize local character variables to ASCII value n
de: -finit-character=<n>	Lokale Zeichenvariablen auf ASCII-Wert n initialisieren

en: -finit-integer=<n>	Initialize local integer variables to n
de: -finit-integer=<n>	Lokale Ganzzahlvariablen auf n initialisieren

en: -finit-logical=<true|false>	Initialize local logical variables
de: -finit-logical=<true|false>	Lokale logische Variablen initialisieren

en: -finit-real=<zero|nan|inf|-inf>	Initialize local real variables
de: -finit-real=<zero|nan|inf|-inf>	Lokale Real-Variablen initialisieren

en: -finline-limit=<number>	Limit the size of inlined functions to <number>
de: -finline-limit=<Zahl>	Größe von »inline«-Funktionen auf <Zahl> beschränken

en: -finput-charset=<cset>	Specify the default character set for source files
de: -finput-charset=<Zeichensatz>	Standard-Zeichensatz für Quelldateien angeben

en: -finstrument-functions-exclude-file-list=filename,...  Do not instrument functions listed in files
de: -finstrument-functions-exclude-file-list=filename,...  In Dateien aufgezählte Funktionen nicht verwenden

en: -finstrument-functions-exclude-function-list=name,...  Do not instrument listed functions
de: -finstrument-functions-exclude-function-list=name,...  Aufgezählte Funktionen nicht verwenden

en: -fira-algorithm=CB does not work on this architecture
de: -fira-algorithm=CB funktioniert auf dieser Architektur nicht

en: -fira-algorithm=[CB|priority] Set the used IRA algorithm
de: -fira-algorithm=[CB|priority] Verwendeten IRA-Algorithmus setzen

en: -fira-region=[one|all|mixed] Set regions for IRA
de: -fira-region=[one|all|mixed] Regionen für IRA setzen

en: -fira-verbose=<number>	Control IRA's level of diagnostic messages.
de: -fira-verbose=<Zahl<	Stufe der IRA Diagnosemeldungen steuern.

en: -fjni and -femit-class-file are incompatible
de: -fjni und -femit-class-file sind unverträglich

en: -fjni and -femit-class-files are incompatible
de: -fjni und -femit-class-files sind unverträglich

en: -fjni is incompatible with -freduced-reflection
de: -fjni ist mit -freduced-reflection unverträglich

en: -flto-compression-level=<number>	Use zlib compression level <number> for IL
de: -flto-compression-level=<Stufe>	Zlib Kompressionsstufe <Stufe> für IL verwenden

en: -fmax-array-constructor=<n>	Maximum number of objects in an array constructor
de: -fmax-array-constructor=<n>	Höchstzahl der Objekte in einem Feldkonstruktor

en: -fmax-errors=<number>	Maximum number of errors to report
de: -fmax-errors=<Anzahl>	Höchstzahl der zu meldenden Fehler

en: -fmax-identifier-length=<n>	Maximum identifier length
de: -fmax-identifier-length=<n>	Größte Bezeichnerlänge

en: -fmax-stack-var-size=<n>	Size in bytes of the largest array that will be put on the stack
de: -fmax-stack-var-size=<n>	Größe des größten Feldes, das auf dem Stack abgelegt wird, in Bytes

en: -fmax-subrecord-length=<n>	Maximum length for subrecords
de: -fmax-subrecord-length=<n>	Größte Länge für Teildatensätze

en: -fmessage-length=<number>	Limit diagnostics to <number> characters per line.  0 suppresses line-wrapping
de: -fmessage-length=<Anzahl>	Diagnosemeldungen auf <Anzahl> Zeichen pro Zeile beschränken. 0 unterdrückt Zeilenumbruch

en: -fno-deduce-init-list	disable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list
de: -fno-deduce-init-list	Unterbindet die Ableitung einer std::initializer_list für den Typ-Parameter eines Templates von einer in Klammern eingeschlossenen Initialisierungsliste

en: -fno-gnu89-inline is only supported in GNU99 or C99 mode
de: -fno-gnu89-inline wird nur im Modus GNU99 oder C99 unterstützt

en: -fno-pretty-templates Do not pretty-print template specializations as the template signature followed by the arguments
de: -fno-pretty-templates Template-Spezialisierungen nicht für die Ausgabe umformatieren als Template-Signatur gefolgt von den Argumenten

en: -fno-threadsafe-statics	Do not generate thread-safe code for initializing local statics
de: -fno-threadsafe-statics	Keinen threadsicheren Code für Initialisierung lokaler statischer Objekte erzeugen

en: -force_flat_namespace not allowed with -dynamiclib
de: -force_flat_namespace ist nicht mit -dynamiclib erlaubt

en: -fpack-struct=<number>	Set initial maximum structure member alignment
de: -fpack-struct=<Zahl>	Anfängliche größte Ausrichtung für Strukturelemente festlegen

en: -fpic and -mapcs-reent are incompatible
de: -fpic und -mapcs-reent sind inkompatibel

en: -fpic is not supported
de: -fpic wird nicht unterstützt

en: -fplugin-arg-<name>-<key>[=<value>]	Specify argument <key>=<value> for plugin <name>
de: -fplugin-arg-<Name>-<Schlüssel>[=<Wert>]	Argument <Schlüssel>=<Wert> für Plugin <Name> angeben

en: -fprefetch-loop-arrays is not supported with -Os
de: -fprefetch-loop-arrays wird nicht mit -Os unterstützt

en: -fprefetch-loop-arrays not supported for this target
de: -fprefetch-loop-arrays wird für dieses Ziel nicht unterstützt

en: -fprefetch-loop-arrays not supported for this target (try -march switches)
de: -fprefetch-loop-arrays wird für dieses Ziel nicht unterstützt (ggf. die »-march«-Schalter versuchen)

en: -frandom-seed=<string>	Make compile reproducible using <string>
de: -frandom-seed=<Zeichenkette>	Übersetzung mit <Zeichenkette> reproduzierbar machen

en: -frecord-gcc-switches is not supported by the current target
de: -frecord-gcc-switches wird für das aktuelle Ziel nicht unterstützt

en: -freorder-blocks-and-partition does not support unwind info on this architecture
de: -freorder-blocks-and-partition unterstützt auf dieser Architektur nicht Unwind-Info

en: -freorder-blocks-and-partition does not work on this architecture
de: -freorder-blocks-and-partition funktioniert auf dieser Architektur nicht

en: -freorder-blocks-and-partition does not work with exceptions on this architecture
de: -freorder-blocks-and-partition funktioniert auf dieser Architektur nicht mit Ausnahmen

en: -freorder-blocks-and-partition not supported on this architecture
de: -freorder-blocks-and-partition wird auf dieser Architektur nicht unterstützt

en: -frepo must be used with -c
de: -frepo muss mit -c verwendet werden

en: -fsched-stalled-insns-dep=<number>	Set dependence distance checking in premature scheduling of queued insns
de: -fsched-stalled-insns-dep=<Zahl>	Prüfung der Abhängigkeitsentfernung in nicht ausgereifter Planung von eingereihten Befehlen setzen

en: -fsched-stalled-insns=<number>	Set number of queued insns that can be prematurely scheduled
de: -fsched-stalled-insns=<Anzahl>	Anzahl der eingereihten Befehle setzen, die unausgereift geplant werden können

en: -fsched-verbose=<number>	Set the verbosity level of the scheduler
de: -fsched-verbose=<Stufe>	Stufe der Wortfülle des Planers angeben

en: -fsplit-stack does not support 2 register  parameters for a nested function
de: -fsplit-stack unterstützt nicht 2 Registerparameter für eine geschachtelte Funktion

en: -fsplit-stack does not support 3 register parameters
de: -fsplit-stack unterstützt nicht 3 Registerparameter

en: -fsplit-stack does not support fastcall with nested function
de: -fsplit-stack unterstützt nicht fastcall mit geschachtelter Funktion

en: -fstack-check=[no|generic|specific]	Insert stack checking code into the program
de: -fstack-check=[no|generic|specific]	Stapelprüfung in das Programm einfügen

en: -fstack-limit-register=<register>	Trap if the stack goes past <register>
de: -fstack-limit-register=<Register>	Wenn der Stapel über <Register> hinausgeht, abfangen (»trap«)

en: -fstack-limit-symbol=<name>	Trap if the stack goes past symbol <name>
de: -fstack-limit-symbol=<Name>	Wenn der Stapel über das Symbol <Name> hinausgeht, abfangen (»trap«)

en: -fstack-protector not supported for this target
de: -fstack-protector wird für dieses Ziel nicht unterstützt

en: -fstack-usage not supported for this target
de: -fstack-usage für dieses Ziel nicht unterstützt

en: -ftabstop=<number>	Distance between tab stops for column reporting
de: -ftabstop=<Zahl>	Tabulatorentfernungen für Spaltenmeldungen

en: -ftemplate-depth=<number>	Specify maximum template instantiation depth
de: -ftemplate-depth=<Zahl>	Größte Template-Instantiierungstiefe angeben

en: -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]	Set the default thread-local storage code generation model
de: -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]	Das standardmäßige Codeerzeugungsmodell für Thread-lokalen Speicher angeben

en: -ftree-vectorizer-verbose=<number>	Set the verbosity level of the vectorizer
de: -ftree-vectorizer-verbose=<Zahl>	Stufe der Wortfülle des Vektorisierers setzen

en: -fuse-linker-plugin, but
de: -fuse-linker-plugin, aber

en: -fvisibility=[default|internal|hidden|protected]	Set the default symbol visibility
de: -fvisibility=[default|internal|hidden|protected]	Standard-Symbolsichtbarkeit setzen

en: -fwide-exec-charset=<cset>	Convert all wide strings and character constants to character set <cset>
de: -fwide-exec-charset=<Zeichensatz>	Alle Wide-Zeichenketten und -konstanten in Zeichenmenge <Zeichensatz> umwandeln

en: -g is only supported when using GAS on this processor,
de: -g wird nur bei der Verwendung von GAS auf diesem Prozessor unterstützt

en: -g option disabled
de: Option -g ausgeschaltet

en: -g with -mno-apcs-frame may not give sensible debugging
de: -g mit -mno-apcs-frame könnte vernünftige Fehlersuche verhindern

en: -gnat<options>	Specify options to GNAT
de: -gnat<Optionen>	Optionen für GNAT angeben

en: -idirafter <dir>	Add <dir> to the end of the system include path
de: -idirafter <Verzeichnis>	<Verzeichnis> an das Ende des System-Einfügepfades anfügen

en: -iframework <dir>	Add <dir> to the end of the system framework include path
de: -iframework <Verz>	<Verz> an das Ende des Einfügepfades des System-Frameworks anfügen

en: -imacros <file>	Accept definition of macros in <file>
de: -imacros <Datei>	Definition von Makros in <Datei> akzeptieren

en: -imultilib <dir>	Set <dir> to be the multilib include subdirectory
de: -imultilib <Verzeichnis>	<Verzeichnis> als Multilib-include-Verzeichnis setzen

en: -include <file>	Include the contents of <file> before other files
de: -include <Datei>	Inhalt von <Datei> vor anderen Dateien einfügen

en: -install_name only allowed with -dynamiclib
de: -install_name ist nur mit -dynamiclib erlaubt

en: -iplugindir <dir> option not passed from the gcc driver
de: Option -iplugindir <Verz> nicht vom GCC-Treiber übergeben

en: -iplugindir=<dir>	Set <dir> to be the default plugin directory
de: -iplugindir=<Verz>	<Verz> als Standard-Plugin-Verzeichnis setzen

en: -iprefix <path>	Specify <path> as a prefix for next two options
de: -iprefix <Pfad>	<Pfad> als ein Präfix für die nächsten zwei Optionen angeben

en: -iquote <dir>	Add <dir> to the end of the quote include path
de: -iquote <Verzeichnis>	<Verzeichnis> am Ende des Einfügepfades in Anführungszeichen anfügen

en: -isysroot <dir>	Set <dir> to be the system root directory
de: -isysroot <verzeichnis>	<Verzeichnis> als System-Wurzelverzeichnis setzen

en: -isystem <dir>	Add <dir> to the start of the system include path
de: -isystem <Verzeichnis>	<Verzeichnis> an den Anfang des System-Einfügepfades anfügen

en: -iwithprefix <dir>	Add <dir> to the end of the system include path
de: -iwithprefix <Verzeichnis>	<Verzeichnis> an das Ende des System-Einfügepfades anfügen

en: -iwithprefixbefore <dir>	Add <dir> to the end of the main include path
de: -iwithprefixbefore <Verz>	<Verz> an das Ende des Haupt-Einfügepfades anfügen

en: -keep_private_externs not allowed with -dynamiclib
de: -keep_private_externs ist mit -dynamiclib nicht erlaubt

en: -m%s not supported in this configuration
de: -m%s wird in dieser Konfiguration nicht unterstützt

en: -m64 not supported in this configuration
de: -m64 wird in dieser Konfiguration nicht unterstützt

en: -m64 requires PowerPC64 architecture, enabling
de: -m64 erfordert PowerPC64-Architektur voraus, eingeschaltet

en: -m64 requires a PowerPC64 cpu
de: -m64 benötigt eine PowerPC64-CPU

en: -mabi=	Specify ABI to use
de: -mabi=	Zu verwendendes ABI

en: -mabi=ABI	Generate code that conforms to the given ABI
de: -mabi=ABI	Code erzeugen, der zum angegebenen ABI passt

en: -maix64 and POWER architecture are incompatible
de: -maix64 und die Architektur POWER sind unverträglich

en: -maix64 required: 64-bit computation with 32-bit addressing not yet supported
de: -maix64 benötigt: 64-Bit-Berechnung mit 32-Bit-Adressierung noch nicht unterstützt

en: -maix64 requires PowerPC64 architecture remain enabled
de: -maix64 setzt eingeschaltete PowerPC64-Architektur voraus

en: -malign-power is not supported for 64-bit Darwin; it is incompatible with the installed C and C++ libraries
de: -malign-power wird für 64-Bit-Darwin nicht unterstützt; es ist mit den installierten C- und C++-Bibliotheken unverträglich

en: -mapcs-stack-check incompatible with -mno-apcs-frame
de: -mapcs-stack-check inkompatibel mit -mno-apcs-frame

en: -march=ARCH	Generate code for the specified chip or CPU version
de: -march=ARCH	Code für die angegebene Chip- oder CPU-Version erzeugen

en: -march=ISA	Generate code for the given ISA
de: -march=ISA	Code für das gegebene ISA erzeugen

en: -mas100-syntax is incompatible with -gdwarf
de: -mas100-syntax ist unverträglich mit -gdwarf

en: -max-stackframe=%d is not usable, not between 0 and %d
de: -max-stackframe=%d ist nicht verwendbar, nicht zwischen 0 und %d

en: -mbackchain -mpacked-stack -mhard-float are not supported in combination
de: -mbackchain -mpacked-stack -mhard-float werden in dieser Kombination nicht unterstützt

en: -mbig-endian and -mlittle-endian may not be used together
de: -mbig-endian und -mlittle-endian dürfen nicht zusammen verwendet werden

en: -mbnu210 is ignored (option is obsolete)
de: -mbnu210 wird ignoriert (veraltete Option)

en: -mbranch-cost=COST	Set the cost of branches to roughly COST instructions
de: -mbranch-cost=KOSTEN	Sprungkosten auf ungefähr KOSTEN Befehle setzen

en: -mc= must be -mc=tiny, -mc=near, or -mc=far
de: -mc= muss -mc=tiny, -mc=near oder -mc=far sein

en: -mcall-aixdesc must be big endian
de: -mcall-aixdesc muss »big endian« sein

en: -mclip currently has no effect without -mminmax
de: -mclip hat ohne -mminmax im Moment keine Auswirkung

en: -mcmodel incompatible with other toc options
de: -mcmodel unverträglich mit anderen TOC-Optionen

en: -mcmodel= is not supported on 32 bit systems
de: -mcmodel= wird auf 32-Bit-Systemen nicht unterstützt

en: -mcode-readable=SETTING	Specify when instructions are allowed to access code
de: -mcode-readable=SETTING	Angeben, wann Befehle zum Codezugriff erlaubt sind

en: -mcorea and -mcoreb can%'t be used together
de: -mcorea und -mcoreb können nicht zusammen verwendet werden

en: -mcorea should be used with -mmulticore
de: -mcorea sollte mit -mmulticore verwendet werden

en: -mcoreb should be used with -mmulticore
de: -mcoreb sollte mit -mmulticore verwendet werden

en: -mcpu=	Use features of and schedule code for given CPU
de: -mcpu=	Eigenschaften der gegebenen CPU verwenden und entsprechend Code planen

en: -mcpu=%s conflicts with -march=%s
de: -mcpu=%s steht in Konflikt mit -march=%s

en: -mcpu=%s has invalid silicon revision
de: -mcpu=%s hat ungültige Silizium-Revision

en: -mcpu=%s is not valid
de: -mcpu=%s ist nicht gültig

en: -mcpu=CPU	Compile code for ARC variant CPU
de: -mcpu=CPU	Code für ARC-Variante CPU planen

en: -mcpu=PROCESSOR		Use features of and schedule code for given CPU
de: -mcpu=PROCESSOR		Eigenschaften der gegebenen CPU verwenden und entsprechend Code planen

en: -mcpu=m16c	Compile code for M16C variants
de: -mcpu=m16c	Code für M16C-Varianten kompilieren

en: -mcpu=m32c	Compile code for M32C variants
de: -mcpu=m32c	Code für M32C-Varianten kompilieren

en: -mcpu=m32cm	Compile code for M32CM variants
de: -mcpu=m32cm	Code für M32CM-Varianten kompilieren

en: -mcpu=r8c	Compile code for R8C variants
de: -mcpu=r8c	Code für R8C-Varianten kompilieren

en: -mdata=SECTION	Put data in SECTION
de: -mdata=SECTION	Daten in SECTION legen

en: -mdebug=	Enable debug output
de: -mdebug=	Ausgaben zur Fehlersuche einschalten

en: -mdynamic-no-pic overrides -fpic or -fPIC
de: -mdynamic-no-pic hebt -fpic oder -fPIC auf

en: -memregs=	Number of memreg bytes (default: 16, range: 0..16)
de: -memregs=	Anzahl der Memreg-Bytes (Standard: 16, Bereich: 0..16)

en: -mfentry isn%'t supported for 32-bit in combination with -fpic
de: -mfentry wird für 32 Bit in Kombination mit -fpic nicht unterstützt

en: -mfloat-abi=hard and VFP
de: -mfloat-abi=hard und VFP

en: -mfloat-gprs=	Select GPR floating point method
de: -mfloat-gprs=	GPR-Gleitkommamethode auswählen

en: -mflush-func=FUNC	Use FUNC to flush the cache before calling stack trampolines
de: -mflush-func=FUNC	FUNC verwenden, um den Cache zu entleeren, bevor Stack-Trampoline aufgerufen werden

en: -mfpu=	Specify FP (sp, dp, sp-lite, dp-lite) (implies -mxilinx-fpu)
de: -mfpu=	FP angeben (sp, dp, sp-lite, dp-lite) (schließt -mxilinx-fpu ein)

en: -mhard-dfp can%'t be used in conjunction with -msoft-float
de: -mhard-dfp kann nicht in Verbindung mit -msoft-float verwendet werden

en: -mhard-float not supported
de: -mhard-float wird nicht unterstützt

en: -mieee not supported on Unicos/Mk
de: -mieee für Unicos/Mk nicht unterstützt

en: -mieee-with-inexact not supported on Unicos/Mk
de: -mieee-with-inexact für Unicos/Mk nicht unterstützt

en: -mincoming-stack-boundary=%d is not between %d and 12
de: -mincoming-stack-boundary=%d ist nicht zwischen %d und 12

en: -mipsN	Generate code for ISA level N
de: -mipsN	Code für ISA Ebene N erzeugen

en: -misel=yes/no	Deprecated option.  Use -misel/-mno-isel instead
de: -misel=yes/no	Veraltete Option. Stattdessen -misel/-mno-isel verwenden

en: -mlong-double-64 not allowed with -m64
de: -mlong-double-64 ist mit -m64 nicht erlaubt

en: -mlong-double-<n>	Specify size of long double (64 or 128 bits)
de: -mlong-double-<n>	Größe von »long double« angeben (64 oder 128 Bits)

en: -mmax-stackframe=SIZE	Warn when a stackframe is larger than the specified size
de: -mmax-stackframe=SIZE	Warnen, wenn ein Stapelrahmen größer als die angegebene Größe ist

en: -mmcu=MCU	Select the target MCU
de: -mmcu=MCU	Die Ziel-MCU auswählen

en: -mmulticore can only be used with BF561
de: -mmulticore kann nur mit BF561 verwendet werden

en: -mmultiple is not supported on little endian systems
de: -mmultiple wird auf »little endian«-Systemen nicht unterstützt

en: -mn is used without -mh or -ms
de: -mn ohne -mh oder -ms verwendet

en: -mno-altivec disables vsx
de: -mno-altivec schaltet vsx aus

en: -mno-clearbss is deprecated; use -fno-zero-initialized-in-bss
de: -mno-clearbss ist veraltet; stattdessen -fno-zero-initialized-in-bss verwenden

en: -mno-fentry isn%'t compatible with SEH
de: -mno-fentry ist nicht mit SEH verträglich

en: -mno-serialize-volatile	Do not serialize volatile memory references with MEMW instructions
de: -mno-serialize-volatile	»volatile«-Speicherreferenzen nicht mit MEMW-Befehlen serialisieren

en: -mpcrel -fPIC is not currently supported on selected cpu
de: -mpcrel -fPIC wird derzeit nicht für die ausgewählte CPU unterstützt

en: -mpic-register= is useless without -fpic
de: -mpic-register= ist ohne -fpic nutzlos

en: -mr10k-cache-barrier=SETTING	Specify when r10k cache barriers should be inserted
de: -mr10k-cache-barrier=SETTING	Angabe, wann R10k Cachegrenzen eingefügt werden sollen

en: -mrecip requires -ffinite-math or -ffast-math
de: -mrecip erfordert -ffinite-math oder -ffast-math

en: -mrecip requires -fno-trapping-math or -ffast-math
de: -mrecip erfordert -fno-trapping-math oder -ffast-math

en: -mrecip requires -freciprocal-math or -ffast-math
de: -mrecip erfordert -freciprocal-math oder -ffast-math

en: -mrelax is only supported for RTP PIC
de: -mrelax wird nur für RTP PIC unterstützt

en: -mrelocatable and -mcall-%s are incompatible
de: -mrelocatable und -mcall-%s sind unverträglich

en: -mrelocatable and -mno-minimal-toc are incompatible
de: -mrelocatable und -mno-minimal-toc sind unverträglich

en: -mrelocatable and -msdata=%s are incompatible
de: -mrelocatable und -msdata=%s sind unverträglich

en: -mrodata=SECTION	Put read-only data in SECTION
de: -mrodata=SECTION	Nur-Lese-Daten in SECTION legen

en: -ms2600 is used without -ms
de: -ms2600 ohne -ms verwendet

en: -msdata=%s and -mcall-%s are incompatible
de: -msdata=%s und -mcall-%s sind unverträglich

en: -msecure-plt not supported by your assembler
de: -msecure-plt wird vom Assembler nicht unterstützt

en: -mshared-library-id= specified without -mid-shared-library
de: -mshared-library-id= ohne -mid-shared-library angegeben

en: -mshared-library-id=%s is not between 0 and %d
de: -mshared-library-id=%s ist nicht zwischen 0 und %d

en: -msim	Use simulator runtime
de: -msim	Simulator-Laufzeitumgebung verwenden

en: -msimple-fpu option ignored
de: Option -msimple-fpu ignoriert

en: -msingle-float and -msoft-float cannot both be specified
de: -msingle-float und -msoft-float können nicht zusammen angegeben werden

en: -msingle-float option equivalent to -mhard-float
de: Option -msingle-float ist äquivalent zu -mhard-float

en: -msoft-float and -mhard_float may not be used together
de: -msoft-float und -mhard_float dürfen nicht zusammen verwendet werden

en: -mspe=yes/no	Deprecated option.  Use -mspe/-mno-spe instead
de: -mspe=yes/no	Veraltete Option. Stattdessen -mspe/-mno-spe verwenden

en: -mstack-guard implies use of -mstack-size
de: -mstack-guard bringt -mstack-size mit sich

en: -mstring is not supported on little endian systems
de: -mstring wird auf »little endian«-Systemen nicht unterstützt

en: -mtext=SECTION	Put functions in SECTION
de: -mtext=SECTION	Funktionen in SECTION legen

en: -mtraceback=	Select full, part, or no traceback table
de: -mtraceback=	Voll-, Teil- oder keine Traceback-Tabelle

en: -mtune=	Schedule code for given CPU
de: -mtune=	Code für die gegebene CPU planen

en: -mtune=ARCH	Tune alignment for the specified chip or CPU version
de: -mtune=ARCH	Ausrichtung für angegebene Chip- oder CPU-Version optimieren

en: -mtune=PROCESSOR	Optimize the output for PROCESSOR
de: -mtune=PROZESSOR	Ausgabe für PROZESSOR optimieren

en: -munix=98 option required for C89 Amendment 1 features.
de: Option -munix=98 für Eigenschaften des C89 Amendment 1 erforderlich.

en: -mvrsave=yes/no	Deprecated option.  Use -mvrsave/-mno-vrsave instead
de: -mvrsave=yes/no	Veraltete Option. Stattdessen -mvrsave/-mno-vrsave verwenden

en: -mvsx and -mno-altivec are incompatible
de: -mvsx und -mno-altivec sind unverträglich

en: -mvsx and -mpaired are incompatible
de: -mvsx und -mpaired sind unverträglich

en: -mvsx needs indexed addressing
de: -mvsx benötigt indizierte Adressierung

en: -mvsx requires hardware floating point
de: -mvsx benötigt Hardware-Gleitkomma

en: -mvsx used with little endian code
de: -mvsx mit Little-Endian-Code verwendet

en: -mxl-multiply-high can be used only with -mcpu=v6.00.a or greater
de: -mxl-multiply-high kann nur mit -mcpu=v6.00.a oder höher verwendet werden

en: -mxl-multiply-high requires -mno-xl-soft-mul
de: -mxl-multiply-high erfordert -mno-xl-soft-mul

en: -mxl_stack_check is deprecated; use -fstack-check
de: -mxl_stack_check ist veraltet; stattdessen -fstack-check verwenden

en: -o <file>	Place output into <file>
de: -o <Datei>	Ausgabe in <Datei> schreiben

en: -pg and -fomit-frame-pointer are incompatible
de: -pg und -fomit-frame-pointer sind unverträglich

en: -pipe ignored because -save-temps specified
de: -pipe ignoriert, da -save-temps angegeben

en: -pipe not supported
de: -pipe wird nicht unterstützt

en: -private_bundle not allowed with -dynamiclib
de: -private_bundle ist mit -dynamiclib nicht erlaubt

en: -static-libgfortran is not supported in this configuration
de: -static-libgfortran wird in dieser Konfiguration nicht unterstützt

en: -trigraphs	Support ISO C trigraphs
de: -trigraphs	Trigraphs nach ISO C unterstützen

en: .NOT. operator in expression at %L must have a LOGICAL operand
de: .NOT.-Operator in Ausdruck bei %L muss einen LOGICAL-Operanden haben

en: 128-bit long double not supported for VAX floats
de: 128-bit long double nicht unterstützt für VAX floats

en: 2 byte cop instructions are not allowed in 64-bit VLIW mode
de: 2-Byte-Cop-Anweisungen sind im 64-Bit VLIW-Modus nicht erlaubt

en: 31 bit ABI
de: 31-Bit-ABI

en: 387 instruction set disabled, using SSE arithmetics
de: 387-Befehlssatz ausgeschaltet, es wird SSE-Arithmetik verwendet

en: 64 bit ABI
de: 64-Bit-ABI

en: 64-bit ABI not supported in ESA/390 mode
de: 64-Bit-ABI nicht unterstützt im ESA/390-Modus

en: 64-bit E500 not supported
de: 64-Bit-E500 wird nicht unterstützt

en: <During initialization>
de: <Während Initialisierung>

en: <anonymous %s>
de: <anonymes %s>

en: <anonymous>
de: <anonym>

en: <brace-enclosed initializer list>
de: <geschweift geklammerte Initialisierungsliste>

en: <built-in>
de: <eingebaut>

en: <command-line>
de: <Kommandozeile>

en: <constant pool index %d not in range>
de: <Konstantenpool-Index %d außerhalb des Wertebereiches>

en: <constant pool index %d unexpected type
de: <Konstantenpool-Index %d mit unerwartetem Typ>

en: <declaration error>
de: <Deklarationsfehler>

en: <enumerator>
de: {Aufzählung}

en: <erroneous-expression>
de: <fehlerhafter-Ausdruck>

en: <expression error>
de: <Ausdrucksfehler>

en: <missing>
de: <fehlt>

en: <return value>
de: <Rückgabewert>

en: <return-value>
de: <Rückgabewert>

en: <statement>
de: <Anweisung>

en: <tag-error>
de: <Markierungsfehler>

en: <template parameter error>
de: <Template-Parameter-Fehler>

en: <throw-expression>
de: <throw-Ausdruck>

en: <type error>
de: <Typfehler>

en: <type-error>
de: <Typ-Fehler>

en: <typedef-error>
de: <typedef-Fehler>

en: <typeprefixerror>
de: <Typpräfixfehler>

en: <unknown operator>
de: <unbekannter Operator>

en: <unknown>
de: <unbekannt>

en: <unnamed-fixed:
de: <unbenannt-Festkomma:

en: <unnamed-float:
de: <unbenannt-Gleitkomma:

en: <unnamed-signed:
de: <unbenannt-vorzeichenbehaftet:

en: <unnamed-unsigned:
de: <unbenannt-vorzeichenlos:

en: <unnamed>
de: <unbenannt>

en: <unparsed>
de: <nicht-analysiert>

en: <unresolved overloaded function type>
de: <unaufgelöster überladener Funktionstyp>

en: @catch parameter can not be protocol-qualified
de: @catch-Parameter kann nicht Protokoll-qualifiziert sein

en: @catch parameter is not a known Objective-C class type
de: »@catch«-Parameter ist kein bekannter Objective-C-Klassentyp

en: A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop
de: Ein Faktor, um die obere Schranke des Swing-Modulo-Schedulers für Schleifenplanung einzustellen

en: A synonym for -std=c89 (for C) or -std=c++98 (for C++)
de: Ein Synonym für -std=c89 (für C) oder -std=c++98 (für C++)

en: A threshold on the average loop count considered by the swing modulo scheduler
de: Schwellwert für vom Swing-Modulo-Scheduler betrachteten Durchschnitts-Schleifen-Zähler

en: AAPCS does not support -mcallee-super-interworking
de: AAPCS unterstützt nicht -mcallee-super-interworking

en: AAPCS does not support -mcaller-super-interworking
de: AAPCS unterstützt nicht -mcaller-super-interworking

en: ABSTRACT INTERFACE '%s' must not be referenced at %L
de: ABSTRACT INTERFACE »%s« darf bei %L nicht referenziert werden

en: ACCESS specification at %L was already specified
de: ACCESS-Spezifikation bei %L wurde bereits spezifiziert

en: ALLOCATABLE specified outside of INTERFACE body at %L
de: ALLOCATABLE außerhalb des INTERFACE-Körpers bei %L angegeben

en: ALLOCATE object
de: ALLOCATE Objekt

en: ALTERNATE RETURN not permitted at %L
de: ALTERNATE RETURN bei %L nicht erlaubt

en: APCS reentrant code not supported.  Ignored
de: wieder einsprungsfähiger APCS Code nicht unterstützt. Ignoriert.

en: ASSERT_EXPR with an always-false condition
de: ASSERT_EXPR mit immer falscher Bedingung

en: ASSIGN statement at %L requires a scalar default INTEGER variable
de: ASSIGN-Anweisung bei %L erfordert eine skalare Standard-INTEGER-Variable

en: ASSIGNED GOTO statement at %L requires an INTEGER variable
de: Anweisung ASSIGNED GOTO bei %L erfordert eine INTEGER-Variable

en: AUX pointer initialized for edge %d->%d
de: AUX-Zeiger für Kante %d->%d initialisiert

en: AVX vector argument without AVX enabled changes the ABI
de: AVX-Vektorargument ohne eingeschaltetes AVX ändert das ABI

en: Accept extensions to support legacy code
de: Erweiterungen akzeptieren, um alten Code zu unterstützen

en: Access data in the same section from shared anchor points
de: Auf Daten im gleichen Abschnitt von gemeinsam benutzten Ankerpunkten zugreifen

en: Access specification of the %s operator at %C has already been specified
de: Zugriffsspezifikation des Operators %s bei %C wurde bereits spezifiziert

en: Access specification of the .%s. operator at %C has already been specified
de: Zugriffsspezifikation des Operators .%s. bei %C wurde bereits spezifiziert

en: Access variables in 32-bit PPU objects (default)
de: Variablen in 32-Bit-PPU-Objekten zugreifen (default)

en: Access variables in 64-bit PPU objects
de: Variablen in 64-Bit-PPU-Objekten zugreifen

en: Actual argument at %L for INTENT(%s) dummy '%s' of ELEMENTAL subroutine '%s' is a scalar, but another actual argument is an array
de: Effektives Argument bei %L für INTENT(%s)-Dummy »%s« von ELEMENTAL-Unterprogramm »%s« ist skalar, aber ein anderes effektives Argument ist ein Feld

en: Actual argument contains too few elements for dummy argument '%s' (%lu/%lu) at %L
de: Effektives Argument enthält zuwenige Elemente für Scheinargument »%s« (%lu/%lu) bei %L

en: Actual argument for '%s' cannot be an assumed-size array at %L
de: Effektives Argument für »%s« kann nicht Feld vermuteter Größe bei %L sein

en: Actual argument for '%s' must be ALLOCATABLE at %L
de: Effektives Argument für »%s« muss ALLOCATABLE bei %L sein

en: Actual argument for '%s' must be a pointer at %L
de: Effektives Argument für »%s« muss ein Zeiger bei %L sein

en: Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)
de: Effektive Zeichenkettenlänge passt nicht zur deklarierten für Scheinargument »%s« (%ld/%ld)

en: Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)
de: Effektive Zeichenkettenlänge ist kürzer als die deklarierte für Scheinargument »%s« (%ld/%ld)

en: Add a common subexpression elimination pass after loop optimizations
de: Einen gemeinsamen Durchlauf zur Entfernung von Teilausdrücken nach Schleifenoptimierungen hinzufügen

en: Add extra commentary to assembler output
de: Zusätzlichen Kommentar an Assemblerausgabe anfügen

en: Add mudflap bounds-checking instrumentation for multi-threaded program
de: Einsatz von Schmutzfänger-Bereichsprüfung für Multi-Thread-Programm hinzufügen

en: Add mudflap bounds-checking instrumentation for single-threaded program
de: Einsatz von Schmutzfänger-Bereichsprüfung für Single-Thread-Programm hinzufügen

en: Additional debug prints
de: Zusätzliche Fehlerprotokollausdrucke

en: Alias for --help=target
de: Alias für --help=target

en: Alias for -femit-class-file
de: Alias für -femit-class-file

en: Alias for -mfloat-abi=hard
de: Alias für -mfloat-abi=hard

en: Alias for -mfloat-abi=soft
de: Alias für -mfloat-abi=soft

en: Align all labels
de: Alle Marken ausrichten

en: Align all loops to 32 byte boundary
de: Alle Schleifen auf 32-Byte-Grenzen ausrichten

en: Align code and data to 32 bits
de: Code und Daten auf 32 Bit ausrichten

en: Align destination of the string operations
de: Ziel der Zeichenkettenoperationen ausrichten

en: Align doubles at 64-bit boundaries
de: Doubles auf 64-Bit-Grenzen ausrichten

en: Align labels which are only reached by jumping
de: Marken ausrichten, die nur mit Sprüngen erreicht werden können

en: Align some doubles on dword boundary
de: Mehrere Doubles auf DWord-Grenze ausrichten

en: Align the start of functions
de: Funktionsanfänge ausrichten

en: Align the start of loops
de: Schleifenanfänge ausrichten

en: Align to the base type of the bit-field
de: Auf Basistyp des Bitfeldes ausrichten

en: Align variables on a 32-bit boundary
de: Variablen auf 32-Bit-Grenzen ausrichten

en: All functions default to the far section
de: Alle Funktionen gehen standardmäßig in den »far«-Abschnitt

en: All intrinsics procedures are available regardless of selected standard
de: Alle eingebauten Prozeduren sind ungeachtet des gewählten Standards verfügbar

en: All variables default to the far section
de: Alle Variablen gehen standardmäßig in den »far«-Abschnitt

en: All variables default to the near section
de: Alle Variablen gehen standardmäßig in den »near«-Abschnitt

en: All variables default to the tiny section
de: Alle Variablen gehen standardmäßig in den »tiny«-Abschnitt

en: Allocatable '%s' at %L cannot have an initializer
de: Zuordnungsfähiges »%s« bei %L kann keine Initialisierung haben

en: Allocatable array '%s' at %L must have a deferred shape
de: Zuordnungsfähiges Feld »%s« bei %L muss aufgeschobene Form haben

en: Allocatable coarray variable '%s' at %L must have deferred shape
de: Zuordnungsfähige Koarray-Variable »%s« bei %L muss aufgeschobene Form haben

en: Allocatable component of structure at %C must have a deferred shape
de: Allozierbare Komponente der Struktur bei %C muss eine aufgeschobene Form haben

en: Allocatable variable '%s' used as a parameter to '%s' at %L must not be an array of zero size
de: Reservierbare Variable »%s«, die als als Parameter für »%s« bei %L verwendet wird, darf kein Feld der Größe Null sein

en: Allocate local variables on the stack to allow indirect recursion
de: Lokale Variablen auf Stack anlegen um indirekte Rekursion zu ermöglichen

en: Allocation would exceed memory limit
de: Reservierung würde Speichergrenze überschreiten

en: Allow a symbol value to be used as an immediate value in an instruction.
de: Symbolwert kann als Immediate-Wert in einem Befehl verwendet werden.

en: Allow arbitrary character line width in fixed mode
de: Im festen Modus beliebig lange Zeilen erlauben

en: Allow arbitrary character line width in free mode
de: Im freien Modus beliebig lange Zeilen erlauben

en: Allow bit-fields to cross word boundaries
de: Zulassen, dass Bitfelder Wortgrenzen überschneiden

en: Allow branches to be packed with other instructions
de: Erlauben, Sprünge mit anderen Befehlen zu packen

en: Allow conversions between __ea and generic pointers (default)
de: Umwandlungen zwischen __ea und allgemeinen Zeigern erlauben (Standard)

en: Allow dollar signs in entity names
de: Dollarzeichen in Entity-Namen erlauben

en: Allow fast jumps to the message dispatcher
de: Schnelle Sprünge zum Nachrichten-Dispatcher erlauben

en: Allow function addresses to be held in registers
de: Vorhalten von Funktionsadressen in Registern erlauben

en: Allow gcc to generate LIW instructions
de: GCC erlauben, LIW-Befehle zu verwenden

en: Allow gcc to use the repeat/erepeat instructions
de: GCC erlauben, den repeat/erepeat-Befehl zu verwenden

en: Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations
de: Hardware-Gleitkommabefehle erlauben, um 32-Bit- und 64-Bit-Befehle abzudecken

en: Allow implicit conversions between vectors with differing numbers of subparts and/or differing element types.
de: Implizite Umwandlungen zwischen Vektoren mit unterschiedlicher Anzahl der Teile und/oder abweichenden Elementtypen erlauben.

en: Allow loop optimizations to assume that the loops behave in normal way
de: Bei Schleifenoptimierungen annehmen, dass sich die Schleifen normal verhalten

en: Allow math optimizations that may violate IEEE or ISO standards
de: Mathematische Optimierungen erlauben, die IEEE- oder ISO-Standards verletzen könnten

en: Allow optimization for floating-point arithmetic which may change the
de: Optimierung für Gleitkommaarithmetik erlauben, bei möglicher Änderung von

en: Allow premature scheduling of queued insns
de: Nicht ausgereifte Planung von eingereihten Befehlen erlauben

en: Allow speculative motion of more loads
de: Spekulative Bewegung bei mehr Ladeoperationen erlauben

en: Allow speculative motion of non-loads
de: Spekulative Bewegung beim Nicht-Laden erlauben

en: Allow speculative motion of some loads
de: Spekulative Bewegung bei einigen Ladeoperationen erlauben

en: Allow the arguments of the '?' operator to have different types
de: Verschiedene Typen für die Argumente des »?«-Operators erlauben

en: Allow the use of MDMX instructions
de: Verwendung von MDMX-Befehlen erlauben

en: Allow the use of MT instructions
de: Verwendung von MT-Befehlen erlauben

en: Allow the use of hardware floating-point ABI and instructions
de: Verwendung von Hardware-Gleitkomma-ABI und -befehlen erlauben

en: Allow two instructions to be issued per cycle
de: Zwei Befehle pro Durchgang erlauben

en: Also if-convert conditional jumps containing memory writes
de: Ebenso if-umwandeln bedingter Sprünge, die Speicherschreiboperationen enthalten

en: Alternate RETURN statement at %C is only allowed within a SUBROUTINE
de: Alternative RETURN-Anweisung bei %C ist nur innerhalb einer SUBROUTINE erlaubt

en: Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier
de: Alternative RETURN-Anweisung bei %L erfordert einen SCALAR-INTEGER-Spezifizierer als Rückgabe

en: Alternate calling convention
de: Alternative Aufrufkonvention

en: Alternate return cannot appear in operator interface at %L
de: Alternative Rückgabe kann nicht in Operatorschnittstelle bei %L auftreten

en: Alternate return specifier in elemental subroutine '%s' at %L is not allowed
de: Alternativer Rückgabespezifizierer in elementarem Unterprogramm »%s« bei %L ist nicht erlaubt

en: Alternate return specifier in function '%s' at %L is not allowed
de: Alternativer Rückgabespezifizierer in Funktion »%s« bei %L ist nicht erlaubt

en: AltiVec and E500 instructions cannot coexist
de: AltiVec- und E500-Befehle können nicht koexistieren

en: AltiVec argument passed to unprototyped function
de: AltiVec-Argument an Funktion ohne Prototyp übergeben

en: AltiVec not supported in this target
de: AltiVec wird für dieses Ziel nicht unterstützt

en: Always check for non gcj generated classes archives
de: Immer auf nicht von gcj erzeugte Klassenarchive prüfen

en: Always generate long calls
de: Immer weite Rufe erzeugen

en: Always treat bitfields as int-sized
de: Bit-Feld immer mit int-Größe behandeln

en: Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack
de: Immer Dynamic Realigned Argument Pointer (DRAP) verwenden, um den Stack neu auszurichten

en: Ambiguous interfaces '%s' and '%s' in %s at %L
de: Mehrdeutige Schnittstellen »%s« und »%s« in %s bei %L

en: Ambiguous symbol in TYPE definition at %C
de: Mehrdeutiges Symbol in TYPE-Definition bei %C

en: Amend appropriate diagnostic messages with the command line option that controls them
de: Die geeignete Diagnosemeldung mit der Kommandozeilenoption erweitern, die sie steuert

en: An alternate return at %L without a * dummy argument
de: Alternative Rückkehr bei %L ohne ein *-Scheinargument

en: An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is:
de: Eine indirekte Kante von %s ist nicht als indirekt markiert und hat keine zugeordnete indirect_info, die zugehörige Anweisung ist:

en: An outer FORALL construct already has an index with this name %L
de: Ein äußeres FORALL-Konstrukt hat bereits einen Index mit Namen %L

en: Annotate assembler instructions with estimated addresses
de: Assemblerbefehle mit geschätzten Adressen kommentieren

en: Append a second underscore if the name already contains an underscore
de: Einen zweiten Unterstrich anhängen, wenn der Name bereits einen Unterstrich enthält

en: Append underscores to externally visible names
de: Unterstriche an extern sichtbare Namen anhängen

en: Apply negative sign to zero values
de: Negatives Vorzeichen auf Null-Werte anwenden

en: Apply variable expansion when loops are unrolled
de: Variablenerweiterung anwenden, wenn Schleifen abgerollt werden

en: Approximate maximum number of instructions to allow between a hint and its branch [125]
de: Ungefähre Höchstzahl der zwischen einem Hinweis und seinem Zweig erlaubten Anweisungen [125]

en: Argument '%s' of elemental procedure at %L cannot have the POINTER attribute
de: Argument »%s« der elementaren Prozedur bei %L kann kein POINTER-Attribut haben

en: Argument '%s' of elemental procedure at %L must be scalar
de: Argument »%s« der elementaren Prozedur bei %L muss skalar sein

en: Argument '%s' of statement function at %L must be scalar
de: Argument »%s« der Anweisungs-Funktion bei %L muss skalar sein

en: Argument '%s' to '%s' at %L must be an associated scalar POINTER
de: Argument »%s« für »%s« bei %L muss ein zugeordneter skalarer POINTER sein

en: Argument NCOPIES of REPEAT intrinsic is negative (its value is %lld)
de: Argument NCOPIES des intrinsischen REPEAT ist negativ (sein Wert ist %lld)

en: Argument NCOPIES of REPEAT intrinsic is negative at %L
de: Argument NCOPIES des intrinsischen REPEAT ist bei %L negativ

en: Argument NCOPIES of REPEAT intrinsic is too large
de: Argument NCOPIES des intrinsischen REPEAT ist zu groß

en: Argument NCOPIES of REPEAT intrinsic is too large at %L
de: Argument NCOPIES des intrinsischen REPEAT ist bei %L zu groß

en: Argument dim at %L must be of INTEGER type
de: Argument dim bei %L muss INTEGER-Typ haben

en: Argument dim at %L must be scalar
de: Argument dim bei %L muss skalar sein

en: Argument of %s at %L must be of length one
de: Argument von %s bei %L muss von der Länge eins sein

en: Argument of %s function at %L is negative
de: Argument der Funktion %s bei %L ist negativ

en: Argument of %s function at %L is too large for the collating sequence of kind %d
de: Argument der Funktion %s bei %L ist zu groß für die zusammenfassende Sequenz der Art %d

en: Argument of %s function at %L outside of range [0,127]
de: Argument der Funktion %s bei %L außerhalb des Wertebereichs [0,127]

en: Argument of ACOS at %L must be between -1 and 1
de: Argument von ACOS bei %L muss zwischen -1 und 1 liegen

en: Argument of ACOSH at %L must not be less than 1
de: Argument von ACOSH bei %L darf nicht kleiner als 1 sein

en: Argument of ASIN at %L must be between -1 and 1
de: Argument von ASIN bei %L muss zwischen -1 und 1 liegen

en: Argument of ATANH at %L must be inside the range -1 to 1
de: Argument von ATANH bei %L muss im Bereich -1 bis 1 liegen

en: Argument of IACHAR at %L must be of length one
de: Argument von IACHAR bei %L muss Länge Eins haben

en: Argument of IACHAR function at %L outside of range 0..127
de: Argument der IACHAR-Funktion bei %L außerhalb des Wertebereiches 0..127

en: Argument of ICHAR at %L must be of length one
de: Argument von ICHAR bei %L muss Länge Eins haben

en: Argument of LOG at %L cannot be less than or equal to zero
de: Argument von LOG bei %L kann nicht kleiner oder gleich Null sein

en: Argument of LOG10 at %L cannot be less than or equal to zero
de: Argument von LOG10 bei %L kann nicht kleiner oder gleich Null sein

en: Argument of SELECT statement at %L cannot be %s
de: Argument der SELECT-Anweisung bei %L kann nicht %s sein

en: Argument of SELECT statement at %L must be a scalar expression
de: Argument der SELECT-Anweisung bei %L muss ein skalarer Ausdruck sein

en: Argument of SQRT at %L has a negative value
de: Argument von SQRT bei %L hat negativen Wert

en: Argument to '%s' at %L is not a variable
de: Argument von »%s« bei %L ist keine Variable

en: Argument to -ffpe-trap is not valid: %s
de: Argument für -ffpe-trap ist nicht gültig: %s

en: Argument types of '%s' intrinsic at %L must match (%s/%s)
de: Argumenttypen des intrinsischen »%s« bei %L müssen passen (%s/%s)

en: Arithmetic IF statement at %L requires a numeric expression
de: Arithmetische IF-Anweisung bei %L erfordert einen numerischen Ausdruck

en: Arithmetic NaN at %L
de: Arithmetisches NaN bei %L

en: Arithmetic NaN converting %s to %s at %L. This check can be disabled with the option -fno-range-check
de: Arithmetisches NaN bei Umwandlung von %s in %s bei %L. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Arithmetic NaN of bit-wise transferred BOZ at %L. This check can be disabled with the option -fno-range-check
de: Arithmetisches NaN des bitweise übertragenen BOZ bei %L. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Arithmetic OK at %L
de: Arithmetik OK bei %L

en: Arithmetic OK converting %s to %s at %L
de: Arithmetik OK beim Konvertieren von %s in %s bei %L

en: Arithmetic overflow at %L
de: Arithmetik-Überlauf bei %L

en: Arithmetic overflow converting %s to %s at %L. This check can be disabled with the option -fno-range-check
de: Arithmetischer Überlauf bei Umwandlung von %s in %s bei %L. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Arithmetic overflow of bit-wise transferred BOZ at %L. This check can be disabled with the option -fno-range-check
de: Arithmetischer Überlauf des bitweise übertragenen BOZ bei %L. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Arithmetic underflow at %L
de: Arithmetik-Unterlauf bei %L

en: Arithmetic underflow converting %s to %s at %L. This check can be disabled with the option -fno-range-check
de: Arithmetischer Unterlauf bei Umwandlung von %s in %s bei %L. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Arithmetic underflow of bit-wise transferred BOZ at %L. This check can be disabled with the option -fno-range-check
de: Arithmetischer Unterlauf des bitweise übertragenen BOZ bei %L. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Array '%s' at %L cannot have a deferred shape
de: Feld »%s« bei %L kann keine aufgeschobene Form haben

en: Array '%s' at %L is a variable, which does not reduce to a constant expression
de: Feld »%s« bei %L ist eine Variable, die nicht zu konstantem Ausdruck reduziert

en: Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object
de: Feld »%s« bei %L mit nicht-konstanten Grenzen kann kein EQUIVALENCE-Objekt sein

en: Array component of structure at %C must have an explicit shape
de: Feldkomponente der Struktur bei %C muss eine explizite Form haben

en: Array component of structure at %C must have explicit or deferred shape
de: Feldkomponente der Struktur bei %C muss explizite oder aufgeschobene Form haben

en: Array element size too big
de: Feldelementgröße zu hoch

en: Array index at %L is an array of rank %d
de: Feldindex bei %L ist ein Feld mit Rang %d

en: Array index at %L must be scalar
de: Feldindex bei %L muss skalar sein

en: Array operands are incommensurate at %L
de: Feld-Operanden sind unzureichend bei %L

en: Array operands are incommensurate converting %s to %s at %L
de: Feldoperanden sind unzureichend beim Konvertieren von %s in %s bei %L

en: Array pointer '%s' at %L must have a deferred shape
de: Feldzeiger »%s« bei %L muss aufgeschobene Form haben

en: Array reference at %C cannot have more than %d dimensions
de: Feldreferenz bei %C kann nicht mehr als %d Dimensionen haben

en: Array reference at %L is out of bounds (%ld < %ld) in dimension %d
de: Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d

en: Array reference at %L is out of bounds (%ld > %ld) in dimension %d
de: Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d

en: Array reference in EQUIVALENCE at %C cannot be an array section
de: Feldreferenz in EQUIVALENCE bei %C kann kein Feldabschnitt sein

en: Array reference out of bounds
de: Feldreferenz außerhalb des Wertebereichs

en: Array section with a vector subscript at %L shall not be the target of a pointer
de: Feldabschnitt mit Vektorindex bei %L sollte nicht das Ziel eines Zeigers sein

en: Array specification at %C has more than %d dimensions
de: Feldspezifikation bei %C hat mehr als %d Dimensionen

en: Array specification for symbol '%s' in COMMON at %C must be explicit
de: Feldspezifikation für Symbol »%s« in COMMON bei %C muss explizit sein

en: Array specification must be deferred at %L
de: Feldspezifikation muss bei %L aufgeschoben werden

en: Array specification required in ALLOCATE statement at %L
de: In ALLOCATE-Anweisung bei %L ist Feld-Spezifikation erforderlich

en: Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute
de: Feldbereich als effektives Argument bei %L ist wegen VOLATILE-Attribut unverträglich mit dem Scheinargument ohne vermutete Form »%s«

en: Assembler options
    =================
de: Assembleroptionen
    =================

en: Assigned label is not a target label
de: Zugewiesene Marke ist keine Zielmarke

en: Assignment operator interface at %L must be a SUBROUTINE
de: Schnittstelle für Zuweisungsoperator bei %L muss eine SUBROUTINE sein

en: Assignment operator interface at %L must have two arguments
de: Schnittstelle des Zuweisungsoperators bei %L muss zwei Argumente haben

en: Assignment operator interface at %L must not redefine an INTRINSIC type assignment
de: Schnittstelle des Zuweisungsoperators bei %L darf keine INTRINSIC Typzuweisung redefinieren

en: Assignment to a FORALL index variable at %L
de: Zuweisung an FORALL-Indexvariable bei %L

en: Assume GAS
de: GAS vermuten

en: Assume ICPLBs are enabled at runtime.
de: Annahme, dass ICPLBs zur Laufzeit aktiviert sind.

en: Assume a large TLS segment
de: Ein großes TLS-Segment vermuten

en: Assume all symbols have 32-bit values
de: Annehmen, dass alle Symbole 32-Bit-Werte haben

en: Assume all variable arg functions are prototyped
de: Annehmen, dass alle Funktionen mit variablen Argumenten Prototypen haben

en: Assume big endian bytes, little endian words
de: »big endian« Bytes und »little endian« Wörter annehmen

en: Assume code will be assembled by GAS
de: Code als mit GAS assembliert annehmen

en: Assume code will be linked by GNU ld
de: Code als später mit GNU ld gebunden annehmen

en: Assume code will be linked by HP ld
de: Code als später mit HP ld gebunden annehmen

en: Assume floating-point operations can trap
de: Annehmen, dass Gleitkommaoperationen abgefangen werden können (»trap«)

en: Assume incoming stack aligned to this power of 2
de: Annahme, dass der ankommende Stack auf diese Zweierpotenz ausgerichtet ist

en: Assume native functions are implemented using JNI
de: Native Funktionen als mit JNI implementiert annehmen

en: Assume no NaNs or infinities are generated
de: Annahme, dass keine NaNs oder Unendlichkeiten erzeugt werden

en: Assume normal C execution environment
de: Normale C-Ausführungsumgebung vermuten

en: Assume possible double misalignment
de: Mögliche doppelte Fehlausrichtung annehmen

en: Assume pt* instructions won't trap
de: Annehmen, dass pt*-Befehle nicht abgefangen werden (»trap«)

en: Assume signed arithmetic overflow wraps around
de: Annehmen, dass vorzeichenbehaftete arithmetische Überläufe regulär überschlagen

en: Assume small address space
de: Kleinen Adressraum annehmen

en: Assume strict aliasing rules apply
de: Annehmen, dass strenge Alias-Regeln gelten

en: Assume symbols might be invalid
de: Annehmen, dass Symbole ungültig seien können

en: Assume target CPU is configured as big endian
de: Ziel-CPU als »big endian«-konfiguriert annehmen

en: Assume target CPU is configured as little endian
de: Ziel-CPU als »little endian«-konfiguriert annehmen

en: Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group
de: Annahme, dass Gleitkomma-Speichern und -Laden wahrscheinlich keinen Konflikt verursachen, wenn sie in eine Befehlsgruppe gelegt werden

en: Assume that receivers of Objective-C messages may be nil
de: Annehmen, dass Empfänger von Objective-C-Nachrichten Null sein können

en: Assume that run-time support has been provided, so omit -lsim from the linker command line
de: Annahme, dass Laufzeitunterstützung vorhanden ist, also wird -lsim von Linker-Kommandozeile ausgelassen

en: Assume that the reciprocal estimate instructions provide more accuracy.
de: Annahme, dass die reziproken abschätzenden Befehle höhere Genauigkeit bieten.

en: Assume that the source file is fixed form
de: Annehmen, dass Quelldatei in fester Form vorliegt

en: Assume that the source file is free form
de: Annehmen, dass Quelldatei in freier Form vorliegt

en: Assume that values of enumeration type are always within the minimum range of that type
de: Nimmt an, dass die Werte einer Aufzählung immer im kleinsten Bereich des Typs liegen

en: Assume the VxWorks RTP environment
de: VxWorks RTP-Umgebung vermuten

en: Assume the VxWorks vThreads environment
de: VxWorks vThreads-Umgebung vermuten

en: Assume the runtime uses a hash table to map an object to its synchronization structure
de: Annehmen, dass die Laufzeitbibliothek eine Hashtabelle verwendet, um ein Objekt zu seiner Synchronisationsstruktur zuzuordnen

en: Assumed shape array '%s' at %L is not permitted in an initialization expression
de: Feld »%s« mit vermuteter Form bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Assumed shape array at %L must be a dummy argument
de: Feld mit vermuteter Form bei %L muss ein Scheinargument sein

en: Assumed size array '%s' at %L is not permitted in an initialization expression
de: Feld »%s« mit vermuteter Größe bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Assumed size array '%s' in %s clause at %L
de: Feld »%s« mit vermuteter Größe in Klausel %s bei %L

en: Assumed size array '%s' in COPYPRIVATE clause at %L
de: Feld »%s« mit vermuteter Größe in Klausel COPYPRIVATE bei %L

en: Assumed size array '%s' in namelist '%s' at %C is not allowed
de: Feld »%s« mit vermuteter Größe in Namensliste »%s« bei %C ist nicht erlaubt

en: Assumed size array '%s' in namelist '%s' at %L is not allowed
de: Feld »%s« mit vermuteter Größe in Namensliste »%s« bei %L ist nicht erlaubt

en: Assumed size array at %L must be a dummy argument
de: Feld mit vermuteter Größe bei %L muss ein Schein-Argument sein

en: Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute
de: Effektives Argument mit vermuteter Form bei %L ist wegen VOLATILE-Attribut unverträglich mit dem Scheinargument ohne vermutete Form »%s«

en: Assumed-shape array '%s' at %L cannot be an argument to the procedure '%s' at %L because the procedure is BIND(C)
de: Feld »%s« mit vermuteter Form bei %L kann kein Argument für Prozedur »%s« bei %L sein, da die Prozedur BIND(C) ist

en: Assumed-shape array '%s' at %L cannot be an argument to the procedure '%s' because it is not C interoperable
de: Feld »%s« bei %L mit vermuteter Form kann kein Argument für Prozedur »%s« sein, da es nicht C-kompatibel ist

en: At global scope:
de: Im globalen Gültigkeitsbereich:

en: At top level:
de: Auf höchster Ebene:

en: Atomically write back software data cache lines (default)
de: Zeilen des Software-Datencache atomar zurückschreiben (Standard)

en: Attempt to DEALLOCATE unallocated '%s'
de: Versuch, nicht reserviertes »%s« freizugeben

en: Attempt to fill delay slots of branch instructions
de: Versuch, die Verzögerungsschlitze der Sprungbefehle auszufüllen

en: Attempt to indirectly overlap COMMON blocks %s and %s by EQUIVALENCE at %C
de: Versuch, die COMMON-Blöcke %s und %s durch EQUIVALENCE bei %C indirekt zu überschneiden

en: Attempt to keep stack aligned to this power of 2
de: Versuch, den Stapel zu dieser Zweierpotenz auszurichten

en: Attempt to merge identical constants across compilation units
de: Versuchen, identische Konstanten über Übersetzungseinheiten hinweg zu verschmelzen

en: Attempt to merge identical constants and constant variables
de: Versuchen, identische Konstanten und konstante Variablen zu verschmelzen

en: Attempt to merge identical debug strings across compilation units
de: Versuchen, identische Zeichenketten zur Fehlersuche über Übersetzungseinheiten hinweg zu verschmelzen

en: Attempting to allocate already allocated variable
de: Versuch, bereits reservierte Variable zu reservieren

en: Attempting to allocate already allocated variable '%s'
de: Versuch, bereits reservierte Variable »%s« zu reservieren

en: Attribute at %L is not allowed in a TYPE definition
de: Attribut bei %L ist in TYPE-Definition nicht erlaubt

en: Auto pre/post decrement increment allowed
de: Auto-Pre-/Post-Decrement-Increment erlaubt

en: Auto pre/post decrement increment not allowed
de: Auto-Pre-/Post-Decrement-Increment nicht erlaubt

en: Automatic array '%s' at %L cannot have an initializer
de: Automatisches Feld »%s« bei %L kann keine Initialisierung haben

en: Automatically align branch targets to reduce branch penalties
de: Zweigziele automatisch ausrichten, um Strafzyklen für Verzweigung zu verringern

en: Avoid all range limits on call instructions
de: Alle Bereichsgrenzen bei Aufrufbefehlen vermeiden

en: Avoid generating pc-relative calls; use indirection
de: Erzeugung PC-relativer Aufrufe verhindern; Indirektion verwenden

en: Avoid generation of indexed load/store instructions when possible
de: Erzeugung indizierter Laden/Speichern-Befehle verhindern, wo möglich

en: Avoid overlapping destination and address registers on LDRD instructions
de: Sich überschneidende Ziel- und Addressregister bei LDRD-Befehlen vermeiden

en: Avoid speculative loads to work around a hardware anomaly.
de: Spekulative Ladeoperationen verhindern, um Hardwarebesonderheiten zu umgehen

en: BB %i can not throw but has an EH edge
de: BB %i kann nicht werfen, hat aber eine EH-Kante

en: BB %i has incorrect edge
de: BB %i hat falsche Kante

en: BB %i has incorrect fallthru edge
de: BB %i hat falsche »fallthru«-Kante

en: BB %i has multiple EH edges
de: BB %i hat mehrere EH-Kanten

en: BB %i is missing an EH edge
de: dem BB %i fehlt eine EH-Kante

en: BB %i is missing an edge
de: dem BB %i fehlt eine Kante

en: BB %i last statement has incorrectly set lp
de: BB %i: letzte Anweisung hat falsch gesetztes LP

en: BB %i too many fallthru edges
de: BB %i hat zu viele »fallthru«-Kanten

en: BB_RTL flag not set for block %d
de: Kennzeichen BB_RTL ist für Block %d nicht gesetzt

en: BIND(C) applied to %s %s at %L
de: BIND(C) auf %s %s bei %L angewendet

en: BIND(C) attribute at %C requires an interface with BIND(C)
de: BIND(C)-Attribut bei %C erfordert eine Schnittstelle mit BIND(C)

en: BIND(C) attribute at %L can only be used for variables or common blocks
de: BIND(C)-Attribut bei %L kann nur für Variablen oder gemeinsame Blöcke verwendet werden

en: BIND(C) procedure with NAME may not have POINTER attribute at %C
de: BIND(C)-Prozedur mit NAME darf kein POINTER-Attribut bei %C haben

en: BLOCK DATA element '%s' at %L must be in COMMON
de: BLOCK DATA Element »%s« bei %L muss in COMMON sein

en: BOZ constant at %L is too large (%ld vs %ld bits)
de: BOZ-konstante bei %L ist zu groß (%ld vs %ld Bits)

en: BOZ literal at %L is bitwise transferred non-integer symbol '%s'
de: BOZ-Literal bei %L ist bitweise übertragenes Nicht-Ganzzahlsymbol »%s«

en: BYTE type used at %C is not available on the target machine
de: Bei %C verwendeter BYTE-Typ ist auf der Zielmaschine nicht verfügbar

en: Bad INTENT specification at %C
de: Falsche INTENT-Spezifikation bei %C

en: Bad IO basetype (%d)
de: Falscher IO-Basistyp (%d)

en: Bad address, not (reg+disp):
de: Falsche Adresse, nicht (reg+disp):

en: Bad address, not register:
de: Falsche Adresse, nicht Register:

en: Bad array reference at %L
de: Ungültige Feldreferenz bei %L

en: Bad array specification for an explicitly shaped array at %C
de: Falsche Feldangabe für Feld mit explizit gebildeter Form bei %C

en: Bad array specification for assumed shape array at %C
de: Falsche Feldangabe für Feld mit durch Vermutung gebildeter Form bei %C

en: Bad array specification for implied-shape array at %C
de: Falsche Feldangabe für Feld mit implizit gebildeter Form bei %C

en: Bad array specification in ALLOCATE statement at %L
de: Falsche Feldspezifikation in ALLOCATE-Anweisung bei %L

en: Bad byte codes.
de: Falsche Bytecodes.

en: Bad character '%c' in OPERATOR name at %C
de: Ungültiges Zeichen »%c« in OPERATOR-Name bei %C

en: Bad continuation line at %C
de: Falsche Fortsetzungszeile bei %C

en: Bad kind expression for function '%s' at %L
de: Falscher Art-Ausdruck für Funktion »%s« bei %L

en: Bad kind for logical constant at %C
de: Falsche Art für Logikkonstante bei %C

en: Bad name
de: Schlechter Name

en: Bad operator
de: Falscher Operator

en: Bad specification for assumed size array at %C
de: Falsche Spezifikation für Feld mit impliziter Größe bei %C

en: Bad specification for deferred shape array at %C
de: Falsche Spezifikation für Feld mit zurückgestellter Form bei %C

en: Bad target in pointer assignment in PURE procedure at %L
de: Falsches Ziel in Zeigerzuweisung in PURE-Prozedur bei %L

en: Bad type in constant expression
de: Falscher Typ in Konstanten-Ausdruck

en: Binding at %C must have the same access as already defined binding '%s'
de: Bindung bei %C muss den selben Zugriff wie bereits definierte Bindung »%s« haben

en: Binding attributes already specify passing, illegal NOPASS at %C
de: Bindeattribute legen bereits Durchleitung fest, unzulässiges NOPASS bei %C

en: Binding attributes already specify passing, illegal PASS at %C
de: Bindeattribute legen bereits Durchleitung fest, unzulässiges PASS bei %C

en: Binding label '%s' at %L collides with global entity '%s' at %L
de: Binde-Marke »%s« bei %L kollidiert mit globalem Eintrag »%s« bei %L

en: Binding label '%s' at %L collides with the global entity '%s' at %L
de: Binde-Marke »%s« bei %L kollidiert mit dem globalen Eintrag »%s« bei %L

en: Binding label '%s' for common block '%s' at %L collides with global entity '%s' at %L
de: Binde-Marke »%s« für Common-Block »%s« bei %L kollidiert mit globalem Eintrag »%s« bei %L

en: Binding label '%s' for common block '%s' at %L collides with the global entity '%s' at %L
de: Binde-Marke »%s« für Common-Block »%s« bei %L kollidiert mit dem globalen Eintrag »%s« bei %L

en: Binding label '%s' for common block '%s' at %L does not match the binding label '%s' for common block '%s' at %L
de: Binde-Marke »%s« für Common-Block »%s« bei %L passt nicht zu Binde-Marke »%s« für Common-Block »%s« bei %L

en: Binding label '%s' in interface body at %L collides with the global entity '%s' at %L
de: Binde-Marke »%s« in Schnittstellenkörper bei %L kollidiert mit dem globalen Eintrag »%s« bei %L

en: Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L
de: Leeres BLOCK DATA bei %C steht in Konflikt mit vorherigem BLOCK DATA bei %L

en: Blanket SAVE statement at %C follows previous SAVE statement
de: Umfassende SAVE-Anweisung bei %C folgt vorheriger SAVE-Anweisung

en: Block label is not appropriate for IF statement at %C
de: Blockmarke ist ungeeignet für IF-Anweisung bei %C

en: Block label not appropriate for arithmetic IF statement at %C
de: Blockmarke passt nicht zu arithmetischer IF-Anweisung bei %C

en: Board name [and memory region].
de: Boardname [und Speicherbereich].

en: Bound on number of candidates below that all candidates are considered in iv optimizations
de: Schranke für Anzahl der Kandidaten, unter der alle Kandidaten in IV-Optimierungen betrachtet werden

en: Bound on number of iv uses in loop optimized in iv optimizations
de: Schranke für Anzahl der IV-Verwendungen in bei IV-Optimierungen optimierter Schleife

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check
de: Schranke für Anzahl der Laufzeitprüfungen, die von Schleifenversionierung des Vektorisierers für Aliasprüfung eingefügt werden

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check
de: Schranke für Anzahl der Laufzeitprüfungen, die von Schleifenversionierung des Vektorisierers für Ausrichtungsprüfung eingefügt werden

en: Bound on size of expressions used in the scalar evolutions analyzer
de: Schranke für Größe von Ausdrücken im skalaren Evolutions-Analysierer verwendet

en: Bound on the complexity of the expressions in the scalar evolutions analyzer
de: Schranke für die Komplexität von Ausdrücken im skalaren Evolutions-Analysierer

en: Bound on the cost of an expression to compute the number of iterations
de: Schranke für die Kosten eines Ausdrucks, um die Anzahl der Durchläufe zu berechnen

en: Bound on the number of equalities in Omega constraint systems
de: Schranke für Anzahl der Gleichungen in Systemen mit Omega-Bedingungen

en: Bound on the number of inequalities in Omega constraint systems
de: Schranke für Anzahl der Ungleichungen in Systemen mit Omega-Bedingungen

en: Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates
de: Schranke für die Anzahl der Iterationen, die der Brute-Force-Algorithmus zur Auswertung der Anzahl von Iterationen auswertet

en: Bound on the number of keys in Omega constraint systems
de: Schranke für Anzahl der Schlüssel in Systemen mit Omega-Bedingungen

en: Bound on the number of variables in Omega constraint systems
de: Schranke für Anzahl der Variablen in Systemen mit Omega-Bedingungen

en: Bound on the number of wild cards in Omega constraint systems
de: Schranke für Anzahl der Wildcards in Systemen mit Omega-Bedingungen

en: Bound on the size of the hash table in Omega constraint systems
de: Schranke für Größe der Hashtabelle in Systemen mit Omega-Bedingungen

en: Branches are this expensive (1-5, arbitrary units)
de: Verzweigungen sind so teuer wie hier angegeben (1-5, beliebige Einheit)

en: Branches executed:%s of %d
de: %s von %d Zweigen ausgeführt

en: Build for Core A
de: Für Kern A bauen

en: Build for Core B
de: Für Kern B bauen

en: Build for SDRAM
de: Für SDRAM bauen

en: By-value argument at %L cannot be an array or an array section
de: Wertargument bei %L kann kein Feld oder Feldabschnitt sein

en: By-value argument at %L is not allowed in this context
de: Wertargument bei %L ist in diesem Kontext nicht erlaubt

en: By-value argument at %L is not of numeric type
de: Wertargument bei %L hat keinen numerischen Typ

en: C interoperable character dummy variable '%s' at %L with VALUE attribute must have length one
de: C-kompatible zeichenwertige Scheinvariable »%s« bei %L mit VALUE-Attribut muss Länge eins haben

en: C kind type parameter is for type %s but type at %L is %s
de: Typ-Parameter nach C-Art ist für Typ %s, aber Typ bei %L ist %s

en: C++ constructors and destructors will not be invoked for Objective-C fields
de: C++-Konstruktoren und -Destruktoren werden für Objective-C-Felder nicht aufgerufen

en: C++ lookup of %qD would return a field, not a type
de: Nachschlagen von %qD würde in C++ ein Feld, keinen Typen zurückgeben

en: C++0x %<constexpr%> only available with -std=c++0x or -std=gnu++0x
de: %<constexpr%> von C++0x nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: C++0x auto only available with -std=c++0x or -std=gnu++0x
de: C++0x »auto« nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: CASE label at %L overlaps with CASE label at %L
de: CASE-Marke bei %L überschneidet sich mit CASE-Marke bei %L

en: CFString literal expression is not a string constant
de: CFString-Literalausdruck ist keine Zeichenkettenkonstante

en: CFString literal is missing
de: CFString-Literal fehlt

en: CHARACTER argument '%s' to '%s' at %L must have a length of 1
de: CHARACTER-Argument »%s« von »%s« bei %L muss Länge 1 haben

en: CHARACTER expression at %L is being truncated (%d/%d)
de: CHARACTER-Ausdruck bei %L wird abgeschnitten (%d/%d)

en: CHARACTER expression will be truncated in assignment (%d/%d) at %L
de: CHARACTER-Ausdruck wird in Zuweisung (%d/%d) bei %L abgeschnitten

en: CHARACTER(*) function '%s' at %L cannot be array-valued
de: CHARACTER(*)-Funktion »%s« bei %L kann nicht Feld-wertig sein

en: CHARACTER(*) function '%s' at %L cannot be pointer-valued
de: CHARACTER(*)-Funktion »%s« bei %L kann nicht Zeiger-wertig sein

en: CHARACTER(*) function '%s' at %L cannot be pure
de: CHARACTER(*)-Funktion »%s« bei %L kann nicht pure sein

en: CHARACTER(*) function '%s' at %L cannot be recursive
de: CHARACTER(*)-Funktion »%s« bei %L kann nicht rekursiv sein

en: CLOSE statement not allowed in PURE procedure at %C
de: CLOSE-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: CODIMENSION specified for '%s' outside its INTERFACE body at %L
de: CODIMENSION für »%s« außerhalb seines INTERFACE-Körpers bei %L angegeben

en: COLLECT_LTO_WRAPPER must be set
de: COLLECT_LTO_WRAPPER muss gesetzt sein

en: COMMON '%s' at %L does not exist
de: COMMON »%s« bei %L existiert nicht

en: COMMON block '%s' at %L is also an intrinsic procedure
de: COMMON-Block »%s« bei %L ist auch eine intrinsische Prozedur

en: COMMON block '%s' at %L is used as PARAMETER at %L
de: COMMON-Block »%s« bei %L wird bei %L als PARAMETER verwendet

en: COMMON block /%s/ not found at %C
de: COMMON-Block /%s/ bei %C nicht gefunden

en: COMPLEX quantities cannot be compared at %L
de: COMPLEX-Größen können nicht bei %L verglichen werden

en: CONTAINS statement at %C is already in a contained program unit
de: CONTAINS-Anweisung bei %C ist bereits in einer enthaltenen Programmeinheit

en: COPYIN clause object '%s' at %L has ALLOCATABLE components
de: Klausel COPYIN - Objekt »%s« hat bei %L ALLOCATABLE-Komponenten

en: COPYPRIVATE clause object '%s' at %L has ALLOCATABLE components
de: Klausel COPYPRIVATE - Objekt »%s« hat bei %L ALLOCATABLE-Komponenten

en: CPU names must be lower case
de: CPU-Namen müssen klein geschrieben sein

en: CPU you selected does not support x86-64 instruction set
de: Die ausgewählte CPU unterstützt nicht den x86-64 Befehlssatz

en: CRIS-port assertion failed:
de: CRIS-Port-Behauptung gescheitert:

en: Call a library routine to do integer divisions
de: Eine Bibiotheksroutine aufrufen, um Ganzahldivision durchzuführen

en: Call mcount for profiling before a function prologue
de: mcount für Profiling vor Funktionsprolog aufrufen

en: Calls executed:%s of %d
de: %s von %d Aufruf(en) ausgeführt

en: Can't USE the same module we're building!
de: Das gerade erzeugte Modul kann nicht gleichzeitig verwendet werden (USE)!

en: Can't convert %s to %s at %L
de: %s kann nicht nach %s bei %L umgewandelt werden

en: Can't find an intrinsic module named '%s' at %C
de: Intrinsisches Modul »%s« bei %C nicht gefunden

en: Can't find keyword named '%s' in call to '%s' at %L
de: Schlüsselwort »%s« in Aufruf von »%s« bei %L kann nicht gefunden werden

en: Can't initialize implied-shape array at %L with scalar
de: Feld mit implizierter Form bei %L kann nicht mit Skalar initialisiert werden

en: Can't open file '%s'
de: Datei »%s« kann nicht geöffnet werden

en: Can't open module file '%s' for reading at %C: %s
de: Moduldatei »%s« kann bei %C nicht zum Lesen geöffnet werden: %s

en: Can't open module file '%s' for writing at %C: %s
de: Moduldatei »%s« kann bei %C nicht zum Schreiben geöffnet werden: %s

en: Cannot IMPORT '%s' from host scoping unit at %C - does not exist.
de: IMPORT »%s« aus Host-Sichtbarkeitseinheit bei %C nicht möglich - existiert nicht.

en: Cannot assign to a named constant at %C
de: An benannte Konstante bei %C kann nicht zugewiesen werden

en: Cannot change attributes of USE-associated symbol %s at %L
de: Attribute des USE-verbundenen Symbols %s bei %L können nicht verändert werden

en: Cannot change attributes of USE-associated symbol at %L
de: Attribute des USE-verbundenen Symbols bei %L können nicht verändert werden

en: Cannot open '%s' for output.
de: »%s« kann nicht zur Ausgabe geöffnet werden.

en: Cannot specify IMPLICIT at %C after IMPLICIT NONE
de: IMPLICIT bei %C kann nicht hinter IMPLICIT NONE angegeben werden

en: Cause gas to print tomcat statistics
de: Gas veranlassen, Tomcat-Statistiken auszugeben

en: Change only the low 8 bits of the stack pointer
de: Nur die unteren 8 Bit des Stapelzeigers verändern

en: Change the ABI to allow double word insns
de: ABI ändern, um Doubleword-Befehle zuzulassen

en: Change the amount of scheduler lookahead
de: Betrag der Vorausplanung ändern

en: Change the maximum length of conditionally-executed sequences
de: Größte Länge der bedingt ausgeführten Sequenzen ändern

en: Change the number of temporary registers that are available to conditionally-executed sequences
de: Anzahl der temporären Register ändern, die für bedingt ausgeführte Sequenzen zur Verfügung stehen

en: Change the stack pointer without disabling interrupts
de: Stapel-Zeiger ändern, ohne Unterbrechung (Interrupt) auszuschalten

en: Changes visibility to match Microsoft Visual Studio by default
de: Sichtbarkeit wird geändert, um standardmäßig zu Microsoft Visual Studio zu passen

en: Character '%s' in string at %L cannot be converted into character kind %d
de: Zeichen »%s« in Zeichenkette bei %L kann nicht in Zeichenart %d umgewandelt werden

en: Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)
de: Zeichenargument »%s« bei %L muss Länge 1 haben, da Prozedur »%s« BIND(C) ist

en: Character dummy variable '%s' at %L with VALUE attribute must have constant length
de: Zeichenwertige Scheinvariable »%s« bei %L mit VALUE-Attribut muss konstante Länge haben

en: Character length mismatch (%ld/%ld) between actual argument and assumed-shape dummy argument '%s' at %L
de: Zeichenlänge passt nicht (%ld/%ld) zwischen effektivem Argument und Scheinargument »%s« mit vermuteter Form bei %L

en: Character length mismatch (%ld/%ld) between actual argument and pointer or allocatable dummy argument '%s' at %L
de: Zeichenlänge passt nicht (%ld/%ld) zwischen effektivem Argument und Zeiger oder reservierbarem Scheinargument »%s« bei %L

en: Character length of actual argument shorter than of dummy argument '%s' (%lu/%lu) at %L
de: Zeichenlänge des effektiven Arguments kürzer als das des Scheinarguments »%s« (%lu/%lu) bei %L

en: Character length of component '%s' needs to be a constant specification expression at %L
de: Zeichenlänge der Komponente »%s« muss ein konstanter Spezifikationsausdruck bei %L sein

en: Character-valued argument '%s' of statement function at %L must have constant length
de: Zeichenwertiges Argument »%s« der Anweisungsfunktion bei %L muss konstante Länge haben

en: Character-valued statement function '%s' at %L must have constant length
de: Zeichenwertige Anweisungsfunktion »%s« bei %L muss konstante Länge haben

en: Check for stack overflow at runtime
de: Zur Laufzeit auf Stapelüberlauf prüfen

en: Check for syntax errors, then stop
de: Auf Syntaxfehler prüfen und anhalten

en: Check the return value of new
de: Rückgabewert von new prüfen

en: Chose strategy to generate stringop using
de: Strategie zur Erzeugung von Zeichenkettenoperationen wählen

en: Cirrus: Place NOPs to avoid invalid instruction combinations
de: Cirrus: NOPs einbauen, um ungültige Befehlskombinationen zu vermeiden

en: Clear the BSS to zero and place zero initialized in BSS
de: BSS komplett löschen und mit Null initialisierte Werte in BSS plazieren

en: Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'
de: Coarray-Hilfsvariable '%s' bei %L in BIND(C)-Prozedur '%s' nicht erlaubt

en: Coarray variable '%s' at %L shall not have codimensions with deferred shape
de: Koarray-Variable »%s« bei %L sollte keine Kodimensionen mit aufgeschobener Form haben

en: Coarrays disabled at %C, use -fcoarray= to enable
de: Coarray bei %C ausgeschaltet, -fcoarray= zum Einschalten verwenden

en: Code size: small, medium or large
de: Code-Größe: klein, mittel, groß

en: Comma required after P descriptor
de: Nach P-Deskriptor Komma benötigt

en: Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure procedure '%s'
de: Allgemeines Blockelement »%s« bei %L kann kein EQUIVALENCE-Objekt in PURE-Prozedur »%s« sein

en: Compare the results of several data dependence analyzers.
de: Die Ergebnisse mehrerer Datenabhängigkeitsanalysen vergleichen.

en: Compile all program units at once and check all interfaces
de: Alle Programmteile zusammen kompilieren und alle Schnittstellen prüfen

en: Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement
de: Code übersetzen, der Cygwin DLL-Wrapper benötigt um C++-Operator new/delete zu ersetzen

en: Compile for 32-bit pointers
de: Für 32-Bit-Zeiger kompilieren

en: Compile for 64-bit pointers
de: Für 64-Bit-Zeiger kompilieren

en: Compile for ETRAX 100 (CRIS v8)
de: Für ETRAX 100 (CRIS v8) übersetzen

en: Compile for ETRAX 4 (CRIS v3)
de: Für ETRAX 4 (CRIS v3) übersetzen

en: Compile for V8+ ABI
de: Für V8+-ABI-übersetzen

en: Compile for a 68HC11
de: Für 68HC11 übersetzen

en: Compile for a 68HC12
de: Für 68HC12 übersetzen

en: Compile for a 68HCS12
de: Für 68HCS12 übersetzen

en: Compile for the Thumb not the ARM
de: Für Thumb statt ARM übersetzen

en: Compile for the m32r
de: Für m32r übersetzen

en: Compile for the m32r2
de: Für m32r2 übersetzen

en: Compile for the m32rx
de: Für m32rx übersetzen

en: Compile for the v850 processor
de: Für v850-Prozessor übersetzen

en: Compile for the v850e processor
de: Für v850e-Prozessor übersetzen

en: Compile for the v850e1 processor
de: Für v850e1-Prozessor übersetzen

en: Compile for the v850e2 processor
de: Für v850e2-Prozessor übersetzen

en: Compile for the v850e2v3 processor
de: Für v850e2v3-Prozessor übersetzen

en: Compile for the v850es variant of the v850e1
de: Für die v850es-Variante des v850e1 übersetzen

en: Compile whole compilation unit at a time
de: Ganze Übersetzungseinheit auf einmal übersetzen

en: Compile with 16-bit integer mode
de: Mit 16-Bit-Ganzzahlmodus übersetzen

en: Compile with 32-bit integer mode
de: Mit 32-Bit-Ganzzahlmodus übersetzen

en: Complex argument of LOG at %L cannot be zero
de: Komplexes Argument von LOG bei %L kann nicht Null sein

en: Complex multiplication and division follow Fortran rules
de: Komplexe Multiplikation und Division folgen Fortran-Regeln

en: Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute
de: Komponente %s des bei %L deklarierten SEQUENCE-Typen hat kein SEQUENCE-Attribut

en: Component '%s' at %C already declared at %L
de: Komponente »%s« bei %C bereits bei %L deklariert

en: Component '%s' at %C already in the parent type at %L
de: Komponente »%s« bei %C bereits im Elterntypen bei %L deklariert

en: Component '%s' at %C is a PRIVATE component of '%s'
de: Komponente »%s« bei %C ist eine PRIVATE-Komponente von »%s«

en: Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type '%s' at %L
de: Komponente »%s« bei %L kann nicht ALLOCATABLE-Attribut haben, da es Element des BIND(C)-abgeleiteten Typs »%s« bei %L ist

en: Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L
de: Komponente »%s« bei %L kann nicht POINTER-Attribut haben, da es Element des BIND(C)-abgeleiteten Typs »%s« bei %L ist

en: Component '%s' in derived type '%s' at %L may not be C interoperable
de: Komponente »%s« in abgeleitetem Typ »%s« bei %L könnte nicht C-kompatibel sein

en: Component '%s' in derived type '%s' at %L may not be C interoperable, even though derived type '%s' is BIND(C)
de: Komponente »%s« in abgeleiteten Typ »%s« bei %L könnte nicht C-kompatibel sein, obwohl abgeleiteter Typ »%s« BIND(C) ist

en: Component '%s' with CLASS at %L must be allocatable or pointer
de: Komponente »%s« mit CLASS bei %L muss allozierbar oder Zeiger sein

en: Component at %C must have the POINTER attribute
de: Komponente bei %C muss ein POINTER-Attribut haben

en: Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L
de: Komponente rechts einer Teilreferenz mit Rang ungleich Null darf bei %L kein Attribut ALLOCATABLE haben

en: Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L
de: Komponente rechts einer Teilreferenz mit Rang größer Null darf kein POINTER-Attribut bei %L haben

en: Components of structure constructor '%s' at %L are PRIVATE
de: Komponenten des Strukturkonstruktors »%s« bei %L sind PRIVATE

en: Concat operator at %L must concatenate strings of the same kind
de: Verkettungsoperator bei %L muss Zeichenketten der gleichen Sorte verketten

en: Concatenation operator in expression at %L must have two CHARACTER operands
de: Verkettungsoperator in Ausdruck bei %L muss zwei CHARACTER-Operanden haben

en: Configuration name
de: Konfigurationsname

en: Configured with: %s
de: Konfiguriert mit: %s

en: Conflict in attributes of function argument at %C
de: Konflikt in Attributen des Funktionsarguments bei %C

en: Conform more closely to IBM XLC semantics
de: Näher der IBM XLC-Semantik entsprechen

en: Conform to nothing in particular
de: Mit nichts besonderem übereinstimmen

en: Conform to the ISO 1990 C standard
de: Mit dem Standard ISO 1990 C übereinstimmen

en: Conform to the ISO 1990 C standard as amended in 1994
de: Mit dem Standard ISO 1990 C, wie 1994 erweitert, übereinstimmen

en: Conform to the ISO 1990 C standard with GNU extensions
de: Mit dem Standard ISO 1990 C mit GNU-Erweiterungen übereinstimmen

en: Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum
de: Mit dem Standard ISO 1998 C++ (mit technischen Korrekturen 2003 überarbeitet) übereinstimmen

en: Conform to the ISO 1998 C++ standard with GNU extensions
de: Mit dem Standard ISO 1998 C++ mit GNU-Erweiterungen übereinstimmen

en: Conform to the ISO 1998 C++ standard, with GNU extensions and
de: Mit dem Standard ISO 1998 C++ mit GNU-Erweiterungen übereinstimmen und

en: Conform to the ISO 1998 C++ standard, with extensions that are likely to
de: Mit dem Standard ISO 1998 C++ mit geeigneten Erweiterungen übereinstimmen

en: Conform to the ISO 1999 C standard
de: Mit dem Standard ISO 1999 C übereinstimmen

en: Conform to the ISO 1999 C standard with GNU extensions
de: Mit dem Standard ISO 1999 C mit GNU-Erweiterungen übereinstimmen

en: Conform to the ISO 201X C standard draft (experimental and incomplete support)
de: Mit dem Standard Draft ISO 201X (experimentelle und unvollstänndige Unterstützung) übereinstimmen

en: Conform to the ISO 201X C standard draft with GNU extensions (experimental and incomplete support)
de: Mit dem Entwurf des C Standards ISO 201X mit GNU-Erweiterungen (experimentelle und unvollstänndige Unterstützung) übereinstimmen

en: Conform to the ISO Fortran 2003 standard
de: Mit dem Standard ISO Fortran 2003 übereinstimmen

en: Conform to the ISO Fortran 2008 standard
de: Mit dem Standard ISO Fortran 2008 übereinstimmen

en: Conform to the ISO Fortran 95 standard
de: Mit dem Standard ISO Fortran 95 übereinstimmen

en: Conform to the Objective-C 1.0 language as implemented in GCC 4.0
de: Mit der in GCC 4.0 implementierten Version Objective-C 1.0 übereinstimmen

en: Consider access to byte sized memory slow
de: Zugriff auf Speicher in Bytegröße als langsam betrachten

en: Consider type 'int' to be 16 bits wide
de: Typ »int« als 16 Bit breit ansehen

en: Consider type 'int' to be 32 bits wide
de: Typ »int« als 32 Bit breit ansehen

en: Const variables default to the near section
de: Konstante Variablen gehen standardwäßig in den near-Abschnitt

en: Constant expression in FORMAT tag at %L must be of type default CHARACTER
de: Konstanter Ausdruck in FORMAT-Markierung bei %L muss vom Standard-CHARACTER-Typ sein

en: Constant expression required at %C
de: Konstanten-Ausdruck erforderlich bei %C

en: ConstantValue attribute of field '%s' has wrong type
de: ConstantValue-Attribut für Feld »%s« hat falschen Typ

en: Construct webs and split unrelated uses of single variable
de: Netze konstruieren und nicht zusammenhängende Verwendungen einzelner Variablen aufteilen

en: Contained function '%s' at %L has no IMPLICIT type
de: Enthaltene Funktion »%s bei %L hat keinen IMPLICIT-Typ«

en: Contained procedure '%s' at %C is already ambiguous
de: Enthaltene Prozedur »%s« bei %C ist bereits mehrdeutig

en: Contained procedure '%s' at %L of a PURE procedure must also be PURE
de: Enthaltene Prozedur »%s« bei %L einer PURE-Prozedur muss auch PURE sein

en: Control the IEEE trap mode
de: Den IEEE-Trap-Modus steuern

en: Control the generated fp rounding mode
de: Den generierten FP-Rundungsmodus steuern

en: Control the precision given to fp exceptions
de: Die Präzision der FP-Ausnahmen steuern

en: Conversion from %s to %s at %L
de: Umwandlung von %s in %s bei %L

en: Conversion of an Infinity or Not-a-Number at %L to INTEGER
de: Umwandlung einer Unendlichkeit oder NaN bei %L in INTEGER

en: Convert conditional jumps in innermost loops to branchless equivalents
de: Umwandlung bedingter Sprünge in innersten Schleifen in zweiglose Äquivalente durchführen

en: Convert floating point constants to single precision constants
de: Gleitkommakonstanten in Konstanten einfacher Genauigkeit umwandeln

en: Copy array sections into a contiguous block on procedure entry
de: Feldabschnitte bei Prozedureintritt in einen zusammenhängenden Block kopieren

en: Cost to assume for a branch insn
de: Für Sprungbefehl anzunehmende Kosten

en: Cost to assume for a multiply insn
de: Für einen Multiplikationsbefehl anzunehmende Kosten

en: Cost to assume for gettr insn
de: Für gettr Befehl anzunehmende Kosten

en: Count speculative dependencies while calculating priority of instructions
de: Spekulative Abhängigkeiten während Prioritätsberechnung der Anweisungen zählen

en: Cray Pointee at %C cannot be assumed shape array
de: Cray-Zeigerende bei %C kann nicht Feld mit impliziter Form sein

en: Cray Pointee at %L appears in multiple pointer() statements
de: Cray-Zeigerende bei %L tritt in mehreren pointer()-Anweisungen auf

en: Cray pointee '%s' in %s clause at %L
de: Cray-Zeigerziel »%s« in Klausel %s bei %L

en: Cray pointee '%s' in SHARED clause at %L
de: Cray-Zeigerziel »%s« in Klausel SHARED bei %L

en: Cray pointer '%s' in %s clause at %L
de: Cray-Zeiger »%s« in Klausel %s bei %L

en: Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes
de: Cray-Zeiger bei %C hat %d Bytes Genauigkeit; Speicheradressen benötigen %d Bytes

en: Cray pointer at %C must be an integer
de: Cray-Zeiger bei %C muss eine Ganzzahl sein

en: Cray pointer declaration at %C requires -fcray-pointer flag
de: Cray-Zeiger-Deklaration bei %C benötigt den Schalter -fcray-pointer

en: Create GUI application
de: GUI-Anwendung erzeugen

en: Create a position independent executable
de: Eine lageunabhängige ausführbare Datei erzeugen

en: Create a shared library
de: Shared Library erzeugen

en: Create canonical induction variables in loops
de: Kanonische Induktionsvariablen in Schleifen erzeugen

en: Create console application
de: Konsolenanwendung erzeugen

en: Create data files needed by "gcov"
de: Von »gcov« benötigte Dateien anlegen

en: DATA array '%s' at %L must be specified in a previous declaration
de: DATA-Feld »%s« bei %L muss in vorheriger Deklaration angegeben werden

en: DATA element '%s' at %L cannot have a coindex
de: DATA-Element '%s' bei %L kann keinen Coindex haben

en: DATA element '%s' at %L is a pointer and so must be a full array
de: DATA-Element '%s' bei %L ist ein Zeiger und muss daher ein vollständiges Feld sein

en: DATA statement at %C is not allowed in a PURE procedure
de: DATA-Anweisung bei %C ist in PURE-Prozedur nicht erlaubt

en: DATA statement at %L has more values than variables
de: DATA-Anweisung bei %L hat mehr Werte als Variablen

en: DATA statement at %L has more variables than values
de: DATA-Anweisung bei %L hat mehr Variablen als Werte

en: DEALLOCATE object
de: DEALLOCATE Objekt

en: DECL_GIMPLE_REG_P set on a variable with address taken
de: DECL_GIMPLE_REG_P auf einer Variable mit verwendeter Adresse gesetzt

en: DIM argument at %L is out of bounds
de: DIM-Argument bei %L ist außerhalb der Grenzen

en: DIM argument without ARRAY argument not allowed for THIS_IMAGE intrinsic at %L
de: DIM-Argument ohne ARRAY-Argument ist für intrinsisches THIS_IMAGE bei %L nicht erlaubt

en: DIMENSION specified for '%s' outside its INTERFACE body at %L
de: DIMENSION für »%s« außerhalb seines INTERFACE-Körpers bei %L angegeben

en: DO step value is zero
de: DO-Schrittwert ist Null

en: DO-iterator '%s' at %L is inside iterator of the same name
de: DO-Iterator »%s« bei %L ist innerhalb eines Iterators mit gleichem Namen

en: DW_LOC_OP %s not implemented
de: DW_LOC_OP %s nicht implementiert

en: Data element above array upper bound at %L
de: Datenelement oberhalb der oberen Feldgrenze bei %L

en: Data element below array lower bound at %L
de: Datenelement unterhalb der unteren Feldgrenze bei %L

en: Data greater than given threshold will go into .ldata section in x86-64 medium model
de: Daten größer als angegebener Schwellwert werden in .ldata-Abschnitt im x86-64 Medium-Modell gehen

en: Data is stored in big-endian format.
de: Daten werden im Big-Endian-Format gespeichert.

en: Data is stored in little-endian format.  (Default).
de: Daten werden im Little-Endian-Format gespeichert (Standard).

en: Data transfer element at %L cannot be a full reference to an assumed-size array
de: Datenübertragungselement bei %L kann keine vollständige Referenz auf Feld vermuteter Größe sein

en: Data transfer element at %L cannot have ALLOCATABLE components
de: Datenübertragungselement bei %L kann keine ALLOCATABLE-Komponenten haben

en: Data transfer element at %L cannot have POINTER components
de: Datenübertragungselement bei %L kann keine POINTER-Komponenten haben

en: Data transfer element at %L cannot have PRIVATE components
de: Datenübertragungselement bei %L kann keine PRIVATE-Komponenten haben

en: Defer popping functions args from stack until later
de: Zurückholen der Funktionsargumente vom Stapel bis auf weiteres hinauszögern

en: Deferred array '%s' at %L is not permitted in an initialization expression
de: Aufgeschobenes Feld »%s bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt«

en: Deferred-shape array '%s' at %L cannot be an argument to the procedure '%s' at %L because the procedure is BIND(C)
de: Feld »%s« mit zurückgestellter Form bei %L kann kein Argument für Prozedur »%s« bei %L sein, da die Prozedur BIND(C) ist

en: Deferred-shape array '%s' at %L cannot be an argument to the procedure '%s' because it is not C interoperable
de: Feld »%s« bei %L mit aufgeschobener Form kann kein Argument für Prozedur »%s« sein, da es nicht C-kompatibel ist

en: Delete useless null pointer checks
de: Unnötige Nullzeigerprügungen löschen

en: Deleted feature: ASSIGN statement at %C
de: Gelöschte Funktion: ASSIGN-Anweisung bei %C

en: Deleted feature: ASSIGNED variable in FORMAT tag at %L
de: Gelöschte Funktion: ASSIGNED-Variable in FORMAT-Markierung bei %L

en: Deleted feature: Assigned GOTO statement at %C
de: Gelöschte Funktion: Zugewiesene GOTO-Anweisung bei %C

en: Deleted feature: PAUSE statement at %C
de: Gelöschte Funktion: PAUSE-Anweisung bei %C

en: Deprecated in favor of -std=c99
de: Veraltet zugunsten von -std=c99

en: Deprecated in favor of -std=gnu99
de: Veraltet zugunsten von -std=gnu99

en: Deprecated in favor of -std=iso9899:1999
de: Veraltet zugunsten von -std=iso9899:1999

en: Deprecated.  This switch has no effect
de: Veraltet. Dieser Schalter hat keine Auswirkung

en: Deprecated.  Use -Os instead
de: Veraltet. Stattdessen -Os verwenden

en: Derived type '%s' at %C is being used before it is defined
de: Abgeleiteter Typ »%s« bei %C wird benutzt bevor er definiert wird

en: Derived type '%s' at %L cannot be declared with both PRIVATE and BIND(C) attributes
de: Abgeleiteter Typ »%s« bei %L kann nicht mit Attributen PRIVATE und BIND(C) deklariert werden

en: Derived type '%s' at %L cannot have the SEQUENCE attribute because it is BIND(C)
de: Abgeleiteter Typ »%s« bei %L kann nicht das SEQUENCE-Attribut haben, da es BIND(C) ist

en: Derived type '%s' at %L has PRIVATE components
de: Abgeleiteter Typ »%s« bei %L hat PRIVATE-Komponenten

en: Derived type '%s' declared at %L must have the BIND attribute to be C interoperable
de: Abgeleiteter Typ »%s«, bei %L deklariert, muss BIND-Attribut haben, um C-kompatibel zu sein

en: Derived type at %C can only be PRIVATE in the specification part of a module
de: Abgeleiteter Typ bei %C kann nur PRIVATE im Spezifikationsteil eines Moduls sein

en: Derived type at %C can only be PUBLIC in the specification part of a module
de: Abgeleiteter Typ bei %C kann nur PUBLIC im Spezifikationsteil eines Moduls sein

en: Derived type at %C has not been previously defined and so cannot appear in a derived type definition
de: Abgeleiteter Typ bei %C wurde vorher nicht definiert und kann daher nicht in einer abgeleiteten Typdefinition auftreten

en: Derived type component %C is not a permitted EQUIVALENCE member
de: Komponente %C abgeleiteten Typs ist kein zulässiges EQUIVALENCE-Element

en: Derived type definition of '%s' at %C has already been defined
de: Abgeleitete Typdefinition von »%s« bei %C wurde bereits definiert

en: Derived type name '%s' at %C already has a basic type of %s
de: Abgeleiteter Typname bei »%s« bei %C hat bereits einen Basistypen von %s

en: Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object
de: Variable »%s« abgeleiteten Typs bei %L kann keine ALLOCATABLE-Komponenten haben, um EQUIVALENCE-Objekt zu sein

en: Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object
de: Variable »%s« abgeleiteten Typs bei %L muss SEQUENCE-Attribut haben, um EQUIVALENCE-Objekt zu sein

en: Derived type variable '%s' at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON
de: Variable »%s« abgeleiteten Typs bei %L mit Standardinitialisierung kann nicht in EQUIVALENCE mit einer Variablen in COMMON sein

en: Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object
de: Variable »%s« abgeleiteten Typs bei %L mit Zeigerkomponenten kann kein EQUIVALENCE-Objekt sein

en: Derived type variable '%s' in COMMON at %L has an ultimate component that is allocatable
de: Variable »%s« abgeleiteten Typs in COMMON bei %L hat eine endgültige Komponente, die allozierbar ist

en: Derived type variable '%s' in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute
de: Variable »%s« abgeleiteten Typs in COMMON bei %L hat weder das SEQUENCE- noch das BIND(C)-Attribut

en: Derived type variable '%s' in COMMON at %L may not have default initializer
de: Variable »%s« abgeleiteten Typs in COMMON bei %L darf nicht Standardinitialisierung haben

en: Description for mxl-mode-bootstrap
de: Beschreibung für mxl-mode-bootstrap

en: Description for mxl-mode-executable
de: Beschreibung für mxl-mode-executable

en: Description for mxl-mode-novectors
de: Beschreibung für mxl-mode-novectors

en: Description for mxl-mode-xmdstub
de: Beschreibung für mxl-mode-xmdstub

en: Determine which dependences between insns are considered costly
de: Feststellen, welche Abhängigkeiten zwischen Befehlen als teuer angesehen werden

en: Different CHARACTER lengths (%d/%d) in array constructor at %L
de: Unterschiedliche CHARACTER-Längen (%d, %d) in Feldkonstruktor bei %L

en: Different CHARACTER lengths (%ld/%ld) in array constructor
de: Unterschiedliche CHARACTER-Längen (%ld/%ld) in Feldkonstruktor

en: Different kind type parameters in pointer assignment at %L
de: Parameter verschiedener Typen in Zeigerzuweisung bei %L

en: Different ranks in pointer assignment at %L
de: Verschiedene Ränge in Zeigerzuweisung bei %L

en: Different shape for %s at %L on dimension %d (%d and %d)
de: andere Form für %s bei %L für Dimension %d (%d und %d)

en: Different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'
de: Unterschiedliche Form für Argumente »%s« und »%s« bei %L für intrinsisches »dot_product«

en: Different shape on dimension 1 for arguments '%s' and '%s' at %L for intrinsic matmul
de: andere Form bei Dimension 1 für Argumente »%s« und »%s« bei %L für intrinsisches matmul

en: Different shape on dimension 2 for argument '%s' and dimension 1 for argument '%s' at %L for intrinsic matmul
de: andere Form bei Dimension 2 für Argument »%s« und Dimension 1 für Argument »%s« bei %L für intrinsisches matmul

en: Dimensions specified for %s at %L after its initialisation
de: Für %s bei %L wurden Dimensionen nach dessen Initialisierung angegeben

en: Disable FP regs
de: Gleitkommaregister ausschalten

en: Disable all optional instructions
de: Alle optionalen Befehle ausschalten

en: Disable bcnz instruction
de: bcnz-Befehl ausschalten

en: Disable floating point optimizations that ignore the IEEE signedness of zero
de: Gleitkommaoptimierungen ausschalten, die die IEEE-Vorzeichenbehaftung von Null nicht beachten

en: Disable hardware floating point
de: Hardware-Gleitkomma ausschalten

en: Disable indexed addressing
de: Indizierte Adressierung ausschalten

en: Disable optimizations observable by IEEE signaling NaNs
de: Von IEEE-Signalisierungs-NaNs wahrnehmbare Optimierungen ausschalten

en: Disable optimizations that assume default FP rounding behavior
de: Optimierungen, die Standard-Rundungsverhalten für Gleitkomma annehmen, ausschalten

en: Disable partioning and streaming
de: Partitionierung und Streaming ausschalten

en: Disable position-independent code (PIC) for use in OS kernel code
de: Lageunabhängigen Code (PIC) für Verwendung in BS-Kernelcode ausschalten

en: Disable preprocessing
de: Vorverarbeitung ausschalten

en: Disable space regs
de: Leerregister ausschalten

en: Disable the use of RX FPU instructions.
de: Verwendung der RX-FPU-Befehle ausschalten.

en: Disallow direct calls to global functions
de: Direkte Aufrufe von globalen Funktionen verbieten

en: Discover pure and const functions
de: Reine und konstante Funktionen entdecken

en: Discover readonly and non addressable static variables
de: Nur-lese und nicht-adressierbare statische Variablen entdecken

en: Display compile time statistics
de: Übersetzungszeitstatistik anzeigen

en: Display contents of a class file in readable form.
de: Inhalt einer Klassendatei in lesbarer Form ausgeben.

en: Display statistics accumulated during compilation
de: Während der Übersetzung angesammelte Statistik anzeigen

en: Display the code tree after front end optimization
de: Codebaum nach Frontend-Optimierung anzeigen

en: Display the code tree after parsing
de: Codebaum nach Analyse anzeigen

en: Display the code tree after parsing; deprecated option
de: Codebaum nach Analyse anzeigen; veraltete Option

en: Display the compiler's version
de: Compiler-Version anzeigen

en: Display this information
de: Diese Informationen anzeigen

en: Division by zero at %L
de: Division durch Null bei %L

en: Division by zero converting %s to %s at %L
de: Division durch Null beim Konvertieren von %s in %s bei %L

en: Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table
de: Divisionsstrategie, eine von: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp call-div1 call-fp, call-table

en: Do dispatch scheduling if processor is bdver1 and Haifa scheduling
de: Bericht-Planung durchführen, wenn Prozessor bdver1 und Haifa-Planung

en: Do not assume GAS
de: Nicht GAS vermuten

en: Do not assume a large TLS segment
de: Kein großes TLS-Segment vermuten

en: Do not assume that standard C libraries and "main" exist
de: Nicht annehmen, dass Standard-C-Bibliotheken und »main« vorhanden sind

en: Do not disable space regs
de: Leerregister nicht ausschalten

en: Do not discard comments
de: Kommentare nicht verwerfen

en: Do not discard comments in macro expansions
de: Kommentare in Makroexpansionen nicht verwerfen

en: Do not display functions compiled or elapsed time
de: Nicht übersetzte Funktionen oder gestoppte Zeit ausgeben

en: Do not emit addressing modes with side-effect assignment
de: Keine Adressierungsmodi mit Seiteneffektzuweisungen ausgeben

en: Do not emit complex integer constants to read-only memory
de: Keine komplexen Ganzzahlkonstanten im Nur-Lese-Speicher erzeugen

en: Do not emit function prologue or epilogue
de: Keinen Funktionsprolog oder -epilog ausgeben

en: Do not enforce strict alignment
de: Genaue Ausrichtung nicht erzwingen

en: Do not generate #line directives
de: Keine #line-Direktiven erzeugen

en: Do not generate .size directives
de: Keine .size-Anweisungen erzeugen

en: Do not generate a single exit point for each function
de: Nicht unbedingt einen einzigen Austrittspunkt für jede Funktion erzeugen

en: Do not generate load/store with update instructions
de: Kein Laden/Speichern mit Aktualisierungsbefehlen erzeugen

en: Do not inline integer division
de: Ganzzahldivision nicht »inline« generieren

en: Do not inline square root
de: Quadratwurzel nicht »inline« generieren

en: Do not load the PIC register in function prologues
de: PIC-Register nicht in Funktionsprolog verschieben

en: Do not mark ABI switches in e_flags
de: ABI-Schalter nicht in e_flags markieren

en: Do not perform optimizations increasing noticeably stack usage
de: Keine Optimierungen durchführen, die die Stackverwendung deutlich erhöhen

en: Do not place floating point constants in TOC
de: Gleitkommakonstanten nicht ins TOC legen

en: Do not place symbol+offset constants in TOC
de: Symbol+Offset-Konstanten nicht ins TOC legen

en: Do not predefine system-specific and GCC-specific macros
de: Keine system- oder GCC-spezifischen Makros vordefinieren

en: Do not pretend that branches are expensive
de: Nicht vorgeben, dass Sprünge teuer sind

en: Do not provide a default start-address 0x100 of the program
de: Keine Standard-Start-Adresse 0x100 des Programmes bereitstellen

en: Do not put uninitialized globals in the common section
de: Keine uninitialisierten globalen Symbole in gemeinsamen Abschnitt legen

en: Do not search standard system include directories (those specified with -isystem will still be used)
de: Standard-System-Einfügepfade nicht durchsuchen (die mit -isystem angegebenen werden trotzdem noch verwendet)

en: Do not search standard system include directories for C++
de: Standard-System-Einfügeverzeichnisse nicht für C++ durchsuchen

en: Do not support SSE4.1 and SSE4.2 built-in functions and code generation
de: Eingebaute SSE4.1- und SSE4.2-Funktionen und Codeerzeugung nicht unterstützen

en: Do not suppress C++ class debug information.
de: Keine Fehlersuchinformationen für C++-Klassen unterdrücken

en: Do not suppress warnings from system headers
de: Nicht Warnungen von System-Headern unterdrücken

en: Do not treat local variables and COMMON blocks as if they were named in SAVE statements
de: Lokale Variablen und COMMON-Blöcke behandeln, als ob sie in SAVE-Anweisungen benannt worden wären

en: Do not tune code and read-only data alignment
de: Ausrichtung von Code und der Nur-Lese-Daten nicht optimieren

en: Do not tune stack alignment
de: Stapelausrichtung nicht optimieren

en: Do not tune writable data alignment
de: Ausrichtung der schreibbaren Daten nicht optimieren

en: Do not use MDMX instructions
de: Keine MDMX-Befehle verwenden

en: Do not use MIPS-3D instructions
de: Keine MIPS-3D-Befehle verwenden

en: Do not use POWER instruction set
de: POWER-Befehlssatz nicht verwenden

en: Do not use PowerPC instruction set
de: PowerPC-Befehlssatz nicht verwenden

en: Do not use VAX fp
de: VAX-FP nicht verwenden

en: Do not use a cache-flushing function before calling stack trampolines
de: Keine Cache entleerende Funktion verwenden, bevor Stack-Trampoline aufgerufen werden

en: Do not use addresses that allocate global registers
de: Nicht globale Register belegende Adressen verwenden

en: Do not use condition codes from normal instructions
de: Keine Bedingungscodes normaler Befehle verwenden

en: Do not use direct addressing mode for soft registers
de: Modus zur direkten Adressierung für Soft-Register nicht verwenden

en: Do not use hardware FP
de: Hardware-FP nicht verwenden

en: Do not use hardware floating point
de: Hardware-Gleitkomma nicht verwenden

en: Do not use hardware fp
de: Hardware-FP nicht verwenden

en: Do not use hardware quad fp instructions
de: Hardware-Vierfach-Gleitkommabefehle nicht verwenden

en: Do not use inline patterns for copying memory
de: Keine Inline-Muster beim Speicherkopieren verwenden

en: Do not use push to store function arguments
de: Keine push-Befehle verwenden, um Funktionsargumente zu speichern

en: Do not use the bit-field instructions
de: Bit-Feld-Befehle nicht verwenden

en: Do not use the callt instruction
de: Den callt-Befehl nicht verwenden

en: Do not use unaligned memory references
de: Keine unausgerichteten Speicherreferenzen verwenden

en: Do not warn about using "long long" when -pedantic
de: Nicht bei Verwendung von »long long« mit -pedantic warnen

en: Do not warn about using variadic macros when -pedantic
de: Nicht bei Verwendung variadischer Makros bei -pedantic warnen

en: Do stack checking using bounds in L1 scratch memory
de: Stack-Überprüfung mit Grenzen im L1-Zwischenspeicher durchführen

en: Do the full register move optimization pass
de: Den vollständigen Optimierungsdurchlauf für Registerbewegungen durchführen

en: Does nothing.  Preserved for backward compatibility.
de: Tut nichts. Für Rückwärtskompatibilität erhalten.

en: Does nothing. Preserved for backward compatibility.
de: Tut nichts. Für Rückwärtskompatibilität erhalten.

en: Don't align items in code or data
de: Code- und Datenelemente nicht ausrichten

en: Don't allocate floats and doubles in extended-precision registers
de: Keine floats und doubles in Registern erweiterter Genauigkeit reservieren

en: Don't call any cache flush functions
de: Keine Funktionen zum Entleeren des Cache aufrufen

en: Don't call any cache flush trap
de: Keine Abfangfunktion zum Entleeren des Cache aufrufen

en: Don't emit DWARF additions beyond selected version
de: Keine DWARF-Ergänzungen über gewählte Version hinaus ausgeben

en: Don't generate checks for control speculation in selective scheduling
de: Keine Prüfungen für Steuerungs-Spekulation in selektiver Planung

en: Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode.
de: Keinen Code nur für privilegierten Modus erzeugen; impliziert -mno-inline-ic_invalidate, wenn der »inline«-Code nicht im Usermodus funktionieren würde

en: Don't optimize block moves
de: Blockkopierbefehle nicht optimieren

en: Don't optimize block moves, use memcpy
de: Blockverschiebungen nicht optimieren sondern memcpy verwenden

en: Don't use P-mnemonics for branches
de: Keine P-Mnemonics für Zweige verwenden

en: Don't warn about uses of Microsoft extensions
de: Nicht bei Verwendung von Microsoft-Erweiterungen warnen

en: Double-precision floating point unit
de: Gleitkommaeinheit mit doppelter Genauigkeit

en: Downgrade conformance errors to warnings
de: Übereinstimmungsfehler zu Warnungen degradieren

en: Driving:
de: Angesteuert:

en: Dummy '%s' at %L cannot have an initializer
de: Schein-»%s« bei %L kann keine Initialisierung haben

en: Dummy argument '%s' at %L cannot be INTENT(OUT)
de: Scheinargument »%s« bei %L kann nicht INTENT(OUT) sein

en: Dummy argument '%s' at %L cannot be OPTIONAL
de: Scheinargument »%s« bei %L kann nicht OPTIONAL sein

en: Dummy argument '%s' at %L was declared INTENT(OUT) but was not set
de: Scheinargument »%s« bei %L war als INTENT(OUT) deklariert, aber nicht gesetzt

en: Dummy argument '%s' not allowed in expression at %L
de: Scheinargument »%s« ist im Ausdruck bei %L nicht erlaubt

en: Dummy procedure '%s' at %C cannot have a generic interface
de: Scheinprozedur »%s« bei %C kann keine allgemeine Schnittstelle haben

en: Dummy procedure '%s' not allowed in elemental procedure '%s' at %L
de: Scheinprozedur »%s« nicht in elementarer Prozedur »%s« bei %L erlaubt

en: Dummy procedure '%s' of PURE procedure at %L must also be PURE
de: Scheinprozedur »%s« der PURE-Prozedur bei %L muss auch PURE sein

en: Dummy procedure at %C may not have BIND(C) attribute with NAME
de: Scheinprozedur bei %C kann kein BIND(C)-Attribut mit NAME haben

en: Dummy procedure at %L not allowed in ELEMENTAL procedure
de: Scheinprozedur bei %L nicht in ELEMENTAL-Prozedur erlaubt

en: Dump a core file when a runtime error occurs
de: Core-Datei abziehen, wenn Laufzeitfehler auftritt

en: Dump declarations to a .decl file
de: Deklaration in .decl-Datei ausgeben

en: Duplicate %s attribute at %L
de: Doppeltes Attribut %s bei %L

en: Duplicate %s attribute specified at %L
de: Attribut %s doppelt angegeben bei %L

en: Duplicate %s label specification at %C
de: Doppelte Markenspezifikation %s bei %C

en: Duplicate %s specification at %C
de: Doppelte Spezifikation %s bei %C

en: Duplicate ASYNCHRONOUS attribute specified at %L
de: Doppeltes ASYNCHRONOUS-Attribut bei %L angegeben

en: Duplicate BIND attribute specified at %L
de: Doppeltes BIND-Attribut bei %L angegeben

en: Duplicate DEFERRED at %C
de: Doppeltes DEFERRED bei %C

en: Duplicate ELSE statements at %L and %C
de: Doppelte ELSE-Anweisungen bei %L und %C

en: Duplicate EXTENDS attribute specified at %L
de: Doppeltes EXTENDS-Attribut bei %L angegeben

en: Duplicate IMPLICIT NONE statement at %C
de: Doppelte IMPLICIT NONE-Anweisung bei %C

en: Duplicate NML specification at %C
de: Doppelte NML-Spezifikation bei %C

en: Duplicate NON_OVERRIDABLE at %C
de: Doppeltes NON_OVERRIDABLE bei %C

en: Duplicate POINTER attribute at %C
de: Doppeltes POINTER-Attribut bei %C

en: Duplicate PRIVATE statement at %C
de: Doppelte PRIVATE-Anweisung bei %C

en: Duplicate PROTECTED attribute specified at %L
de: Doppeltes PROTECTED-Attribut bei %L angegeben

en: Duplicate SAVE attribute specified at %L
de: SAVE-Attribut doppelt angegeben bei %L

en: Duplicate SEQUENCE statement at %C
de: Doppelte SEQUENCE-Anweisung bei %C

en: Duplicate UNIT specification at %C
de: Doppelte UNIT-Spezifikation bei %C

en: Duplicate VALUE attribute specified at %L
de: Doppeltes VALUE-Attribut bei %L angegeben

en: Duplicate VOLATILE attribute specified at %L
de: Doppeltes VOLATILE-Attribut bei %L angegeben

en: Duplicate access-specifier at %C
de: Doppelte Zugriffsspezifikation bei %C

en: Duplicate array spec for Cray pointee at %C
de: Doppelte Feldspezifikation für Cray-Zeigerende bei %C

en: Duplicate construct label '%s' at %C
de: Doppelte Aufbau-Marke »%s« bei %C

en: Duplicate format specification at %C
de: Doppelte Format-Spezifikation bei %C

en: Duplicate statement label %d at %L and %L
de: Doppelte Anweisungsmarke %d bei %L und %L

en: Duplicate symbol '%s' in formal argument list at %C
de: Doppeltes Symbol »%s« in formaler Argumentliste bei %C

en: Dynamically allocate cc registers
de: CC-Register dynamisch belegen

en: E specifier not allowed with g0 descriptor
de: E-Symbol nicht erlaubt mit g0-Deskriptor

en: E500 and FPRs not supported
de: E500 und FPRs werden nicht unterstützt

en: EH landing pad label
de: EH Landefeld-Marke

en: ELEMENTAL function '%s' at %L must have a scalar result
de: Elementare Funktion »%s« bei %L muss ein skalares Ergebnis haben

en: ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L
de: Elementare nicht-intrinsische Prozedur »%s« ist nicht als effektives Argument bei %L erlaubt

en: ELSE IF statement at %C cannot follow ELSE statement at %L
de: ELSE-IF-Anweisung bei %C kann nicht auf eine ELSE-Anweisung bei %L folgen

en: ELSEWHERE statement at %C follows previous unmasked ELSEWHERE
de: Anweisung ELSEWHERE bei %C folgt zuvor unmaskiertem ELSEWHERE

en: ELSEWHERE statement at %C not enclosed in WHERE block
de: ELSEWHERE-Anweisung bei %C nicht eingeschlossen in WHERE-Block

en: END tag at %C not allowed in output statement
de: END-Tag bei %C in Ausgabe-Anweisung nicht erlaubt

en: END tag label %d at %L not defined
de: END-Marke %d bei %L nicht definiert

en: ENTRY '%s' at %L has no IMPLICIT type
de: ENTRY »%s« bei %L hat keinen IMPLICIT-Typ

en: ENTRY result %s can't be a POINTER in FUNCTION %s at %L
de: ENTRY-Ergebnis %s kann kein POINTER in FUNCTION %s bei %L sein

en: ENTRY result %s can't be an array in FUNCTION %s at %L
de: ENTRY-Ergebnis %s kann kein Feld in FUNCTION %s bei %L sein

en: ENTRY result %s can't be of type %s in FUNCTION %s at %L
de: ENTRY-Ergebnis %s kann nicht vom Typ %s in FUNCTION %s bei %L sein

en: ENTRY statement at %C cannot appear in a contained procedure
de: ENTRY-Anweisung bei %C kann nicht in einer enthaltenen Prozedur auftreten

en: ENTRY statement at %C cannot appear within a BLOCK DATA
de: ENTRY-Anweisung bei %C kann nicht innerhalb von BLOCK DATA auftreten

en: ENTRY statement at %C cannot appear within a DERIVED TYPE block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines DERIVED TYPE Blockes auftreten

en: ENTRY statement at %C cannot appear within a DO block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines DO-Blockes auftreten

en: ENTRY statement at %C cannot appear within a FORALL block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines FORALL-Blockes auftreten

en: ENTRY statement at %C cannot appear within a MODULE
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines MODULEs auftreten

en: ENTRY statement at %C cannot appear within a PROGRAM
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines PROGRAMmes auftreten

en: ENTRY statement at %C cannot appear within a SELECT block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines SELECT-Blockes auftreten

en: ENTRY statement at %C cannot appear within a WHERE block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines WHERE-Blockes auftreten

en: ENTRY statement at %C cannot appear within a contained subprogram
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines enthaltenen Subprogrammes auftreten

en: ENTRY statement at %C cannot appear within an IF-THEN block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines IF-THEN-Blockes auftreten

en: ENTRY statement at %C cannot appear within an INTERFACE
de: ENTRY-Anweisung bei %C kann nicht innerhalb von INTERFACE auftreten

en: ENTRY_BLOCK has IL associated with it
de: ENTRY_BLOCK hat zugehörige IL

en: ENUM declaration at %C has no ENUMERATORS
de: ENUM-Deklaration bei %C hat keine ENUMERATORen

en: ENUM definition statement expected before %C
de: Anweisung zur ENUM-Definition vor %C erwartet

en: ENUMERATOR %L not initialized with integer expression
de: ENUMERATOR %L nicht mit Ganzzahlausdruck initialisiert

en: EOR tag label %d at %L not defined
de: EOR-Marke %d bei %L nicht definiert

en: EQUIVALENCE at %C requires two or more objects
de: EQUIVALENCE bei %C erfordert zwei oder mehr Objekte

en: ERR tag label %d at %L not defined
de: ERR-Marke %d bei %L nicht definiert

en: ERRMSG variable
de: ERRMSG-Variable

en: ESA/390 architecture
de: ESA/390-Architektur

en: EXIT statement at %C terminating !$OMP DO loop
de: EXIT-Anweisung bei %C beendet !$OMP DO Schleife

en: EXIT_BLOCK has IL associated with it
de: EXIT_BLOCK hat zugehörige IL

en: Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute
de: Entweder alle oder keines der Objekte in bei %L gesetztem EQUIVALENCE sollte das Attribut PROTECTED haben

en: Element in %s array constructor at %L is %s
de: Element in Feldkonstruktor %s bei %L ist %s

en: Embedded space in NAME= specifier at %C
de: Eingeschlossenes Leerzeichen in NAME=-Spezifizierung bei %C

en: Emit 16-bit relocations to the small data areas
de: 16-bit Auslagerungen in kleinen Datenbereichen erzeugen

en: Emit 32-bit relocations to the small data areas
de: 32-bit Auslagerungen in kleinen Datenbereichen erzeugen

en: Emit DWARF additions beyond selected version
de: DWARF-Ergänzungen über gewählte Version hinaus ausgeben

en: Emit IEEE-conformant code, without inexact exceptions
de: IEEE-konformen Code erzeugen, ohne ungenaue Ausnahmen

en: Emit call graph information
de: Informationen zum Aufrufgraph ausgeben

en: Emit cmpeqdi_t pattern even when -mcbranchdi is in effect.
de: cmpeqdi_t-Muster ausgeben, sogar wenn -mcbranchdi aktiv ist.

en: Emit code for the byte/word ISA extension
de: Code für die Byte/Word-ISA-Erweiterung erzeugen

en: Emit code for the counting ISA extension
de: Code für die zählende ISA-Erweiterung erzeugen

en: Emit code for the fp move and sqrt ISA extension
de: Code für die FP-Move- und SQRT-ISA-Erweiterung erzeugen

en: Emit code for the motion video ISA extension
de: Code für die Video-ISA-Erweiterung erzeugen

en: Emit code using explicit relocation directives
de: Code mit expliziten Auslagerungsanweisungen erzeugen

en: Emit common-like symbols as weak symbols
de: Common-ähnliche Symbole als schwache Symbole ausgeben

en: Emit direct branches to local functions
de: Direkte Zweige in lokalen Funktionen erzeugen

en: Emit errors when run-time relocations are generated
de: Fehler melden, wenn Verschiebungen zur Laufzeit erzeugt werden

en: Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit
de: Zusätzlichen Code im Funktionsprolog ausgeben, um ein Überschreiten des angegebenen Limits für die Stackgröße abzufangen (trap)

en: Emit function-calls using global offset table when generating PIC
de: Bei PIC-Erzeugung Funktionsaufrufe ausgeben, die die globale Offsettabelle verwenden

en: Emit implicit instantiations of inline templates
de: Implizite Instantiierungen von »inline«-Templates ausgeben

en: Emit implicit instantiations of templates
de: Implizite Instantiierungen von Templates ausgeben

en: Emit indirect branches to local functions
de: Direkte Zweige in lokalen Funktionen erzeugen

en: Emit long load/store sequences
de: Lange Laden/Speichern-Folgen ausgeben

en: Emit profiling counter call at function entry before prologue.
de: Profiling-Zähleraufruf am Funktionsanfang vor Prolog ausgeben.

en: Emit rdval instead of rduniq for thread pointer
de: rdval statt rduniq für Thread-Zeiger erzeugen

en: Emit static const variables even if they are not used
de: Statische konstante Variablen erzeugen, auch wenn sie nicht verwendet werden

en: Emit stop bits before and after volatile extended asms
de: Vor und nach flüchtig erweiterten asms Stop-Bits ausgeben

en: Emit verbose debug information in assembly code
de: Ausführliche Informationen zur Fehlersuche im Assemblercode ausgeben

en: Emit warnings when run-time relocations are generated
de: Warnen, wenn Verschiebungen zur Laufzeit erzeugt werden

en: Empty IMPLICIT statement at %C
de: Leere IMPLICIT-Anweisung bei %C

en: Empty array constructor at %C is not allowed
de: Leerer Feldkonstruktor bei %C ist nicht erlaubt

en: Empty set of digits in BOZ constant at %C
de: Leere Ziffernmenge in BOZ-Konstante bei %C

en: Enable 32-bit divide instructions
de: 32-Bit-Divisionsbefehle einschalten

en: Enable 32-bit multiply instructions
de: 32-Bit-Multiplikations-Befehle einschalten

en: Enable CFI tables via GAS assembler directives.
de: CFI-Tabellen über GAS-Assembler-Anweisungen einschalten

en: Enable Dwarf 2 line debug info via GNU as
de: Dwarf-2-Zeilenfehlersuchinfo über GNU as einschalten

en: Enable Full Redundancy Elimination (FRE) on trees
de: Vollständige Redundanzentfernung (FRE) auf Bäumen einschalten

en: Enable Function Descriptor PIC mode
de: Funktionsdeskriptor-PIC-Modus einschalten

en: Enable Graphite Identity transformation
de: Transformation der Graphite Identität einschalten

en: Enable ID based shared library
de: ID-basierte Shared Library einschalten

en: Enable IVC2 scheduling
de: IVC2-Planung einschalten

en: Enable Loop Blocking transformation
de: Transformation des Loop Blocking einschalten

en: Enable Loop Flattening transformation
de: Transformation des Loop Flattening einschalten

en: Enable Loop Interchange transformation
de: Transformation des Loop Interchange einschalten

en: Enable Loop Strip Mining transformation
de: Transformation des Loop Strip Mining einschalten

en: Enable MeP Coprocessor
de: MeP-Koprozessor einschalten

en: Enable MeP Coprocessor with 32-bit registers
de: MeP-Koprozessor mit 32-Bit-Registern einschalten

en: Enable MeP Coprocessor with 64-bit registers
de: MeP-Koprozessor mit 64-Bit-Registern einschalten

en: Enable Objective-C exception and synchronization syntax
de: Objective-C-Ausnahme- und -Synchronisations-Syntax einschalten

en: Enable Objective-C setjmp exception handling runtime
de: Laufzeitbibliothek zur Objective-C setjmp-Ausnahmebehandlung einschalten

en: Enable OpenMP (implies -frecursive in Fortran)
de: OpenMP aktivieren (impliziert -frecursive in Fortran)

en: Enable PIC support for building libraries
de: PIC-Unterstützung beim Bauen von Bibliotheken einschalten

en: Enable Plan 9 language extensions
de: Plan 9 Spracherweiterungen zulassen

en: Enable SH5 cut2 workaround
de: SH5-cut2-Workaround einschalten

en: Enable SSA code sinking on trees
de: SSA-Codeversenkung auf Bäumen einschalten

en: Enable SSA dead code elimination optimization on trees
de: Beseitigungsoptimierung für toten SSA-Code auf Bäumen einschalten

en: Enable SSA-BIT-CCP optimization on trees
de: SSA-BIT-CCP-Optimierungen auf Bäumen einschalten

en: Enable SSA-CCP optimization on trees
de: SSA-CCP-Optimierungen auf Bäumen einschalten

en: Enable SSA-PRE optimization on trees
de: SSA-PRE-Optimierungen auf Bäumen einschalten

en: Enable TPF-OS tracing code
de: TPF-OS-tracing-Code einschalten

en: Enable absolute difference instructions
de: Absolute Differenzbefehle aktivieren

en: Enable alignment of COMMON blocks
de: Ausrichtung von COMMON-Blöcken einschalten

en: Enable all -Wunused- warnings
de: Alle -Wunused- Warnungen einschalten

en: Enable all optional instructions
de: Alle optionalen Befehle einschalten

en: Enable an RTL peephole pass before sched2
de: Einen RTL-Guckloch-Durchlauf vor sched2 einschalten

en: Enable assignability checks for stores into object arrays
de: Zuweisbarkeitsprüfungen für Speicheroperationen in Objektfelder einschalten

en: Enable automatic parallelization of loops
de: Automatische Parallelisierung von Schleifen einschalten

en: Enable automatic template instantiation
de: Automatische Template-Instantiierung einschalten

en: Enable average instructions
de: Mittelwertbefehle einschalten

en: Enable backend debugging
de: Backend-Fehlersuche einschalten

en: Enable barrel shift instructions
de: Rohr-Bitschiebebefehle einschalten

en: Enable basic block vectorization (SLP) on trees
de: Vektorisierung von Basisblöcken (SLP) auf Bäumen einschalten

en: Enable basic program profiling code
de: Einfachen Programm-Profilierungscode einschalten

en: Enable bit manipulation instructions
de: Bitmanipulationsbefehle einschalten

en: Enable cbranchdi4 pattern
de: cbranchdi4-Muster einschalten

en: Enable clip instructions
de: Clip-Befehle einschalten

en: Enable common options for generating profile info for profile feedback directed optimizations
de: Allgemeine Optionen zum Erzeugen von Profil-Info für Profil-Feedback-gerichtete Optimierungen einschalten

en: Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=
de: Allgemeine Optionen zum Erzeugen von Profil-Info für Profil-Feedback-gerichtete Optimierungen einschalten, und -fprofile-dir= setzen

en: Enable common options for performing profile feedback directed optimizations
de: Allgemeine Optionen zum Durchführen von Profil-Feedback-gerichteten Optimierungen einschalten

en: Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=
de: Allgemeine Optionen zum Durchführen von Profil-Feedback-gerichteten Optimierungen einschalten, und -fprofile-dir= setzen

en: Enable conditional dead code elimination for builtin calls
de: Beseitigung von bedingt totem Code für Aufrufe eingebauter Funktionen einschalten

en: Enable conditional execution other than moves/scc
de: Bedingte Ausführung statt Kopieren/scc einschalten

en: Enable conditional moves
de: Bedingte Kopierbefehle einschalten

en: Enable copy propagation of scalar-evolution information.
de: Kopieweitergabe von Informationen über Skalar-Evolution einschalten.

en: Enable copy propagation on trees
de: Kopieweitergabe auf Bäumen einschalten

en: Enable dead store elimination
de: Entfernung toter Speicherbereiche einschalten

en: Enable debug output to be generated.
de: Ausgaben zur Fehlersuche einschalten.

en: Enable decimal floating point hardware support
de: Hardwareunterstützung für dezimales Gleitkomma einschalten

en: Enable divide and modulus instructions
de: Divisions- und Modulobefehle einschalten

en: Enable dominator optimizations
de: Beherrscher-Optimierungen einschalten

en: Enable earlier placing stop bits for better scheduling
de: Frühere Stop-Bit-Platzierung für bessere Planung einschalten

en: Enable exception handling
de: Ausnahmebehandlung einschalten

en: Enable forward propagation on trees
de: Vorwärts-Übertragung auf Bäumen einschalten

en: Enable function profiling
de: Funktionsprofilierung einschalten

en: Enable garbage collection (GC) in Objective-C/Objective-C++ programs
de: Garbage Collection (GC) in Objective-C/Objective-C++-Programmen einschalten

en: Enable guessing of branch probabilities
de: Erraten der Sprungwahrscheinlichkeiten einschalten

en: Enable hardware floating point
de: Hardware-Gleitkomma einschalten

en: Enable hoisting loads from conditional pointers.
de: Herausziehen von Ladeoperationen aus bedingten Zeigern einschalten

en: Enable in and out of Graphite representation
de: Ein- und Ausgabe der Graphite-Repräsentierung einschalten

en: Enable inlining of PLT in function calls
de: Inlining von PLT in Funktionsaufrufen einschalten

en: Enable label alignment optimizations
de: Markenausrichtungs-Optimierungen einschalten

en: Enable leading zero instructions
de: Führende Null-Befehle einschalten

en: Enable link-time optimization.
de: Optimierungen zur Linkzeit einschalten

en: Enable linker optimizations
de: Binder-Optimierungen einschalten

en: Enable linker relaxation.
de: Binderlockerung einschalten.

en: Enable linker relaxations
de: Binderlockerungen einschalten

en: Enable linker relaxing
de: Binderlockerung einschalten

en: Enable loop distribution for patterns transformed into a library call
de: Schleifenverteilung für in Bibliotheksaufruf umgewandelte Muster einschalten

en: Enable loop distribution on trees
de: Schleifenverteilung auf Bäumen einschalten

en: Enable loop header copying on trees
de: Kopieren des Schleifenkopfes auf Bäumen einschalten

en: Enable loop interchange transforms.  Same as -floop-interchange
de: Umwandlungen mit Schleifenaustausch einschalten. Das Gleiche wie -floop-interchange

en: Enable loop invariant motion on trees
de: Bewegung der Schleifeninvariante auf Bäumen einschalten

en: Enable loop optimizations on tree level
de: Schleifenoptimierungen auf Baumebene einschalten

en: Enable loop vectorization on trees
de: Schleifenvektorisierung auf Bäumen einschalten

en: Enable loop versioning when doing loop vectorization on trees
de: Schleifenversionierung bei Schleifenvektorisierung auf Bäumen einschalten

en: Enable machine specific peephole optimizations
de: Maschinenspezifische Guckloch-Optimierungen einschalten

en: Enable min/max instructions
de: Min/Max-Befehle einschalten

en: Enable most warning messages
de: Die meisten Warnungen einschalten

en: Enable multicore support
de: Multicore-Unterstützung einschalten

en: Enable multiply instructions
de: Multiplikationsbefehle einschalten

en: Enable nested conditional execution optimizations
de: Optimierungen für geschachtelte bedingte Ausführung einschalten

en: Enable optimization of static class initialization code
de: Optimierung des Initialisierungscodes statischer Klassen einschalten

en: Enable optimizing &&/|| in conditional execution
de: Optimierung von &&/|| in bedingter Ausführung einschalten

en: Enable preprocessing
de: Vorverarbeitung einschalten

en: Enable range checking during compilation
de: Bereichsprüfung während Kompilierung einschalten

en: Enable reassociation on tree level
de: Neuverbindung auf Baumebene einschalten

en: Enable saturation instructions
de: Sättigungsbefehle einschalten

en: Enable scheduling across basic blocks
de: Planung über Basisblöcke hinaus einschalten

en: Enable separate data segment
de: Gesondertes Datensegment einschalten

en: Enable setting GPRs to the result of comparisons
de: Setzen von GPRs auf das Ergebnis von Vergleichen einschalten

en: Enable sign extend instructions
de: Vorzeichenerweiternde Befehle einschalten

en: Enable stack probing
de: Stapelsondierung einschalten

en: Enable strict 32-bit psABI struct return checking.
de: Strenge Prüfung für 32-bit psABI Strukturrückgabe einschalten

en: Enable the critical path heuristic in the scheduler
de: Critical-Path-Heuristik im Planer einschalten

en: Enable the group heuristic in the scheduler
de: Gruppenheuristik im Planer einschalten

en: Enable the last instruction heuristic in the scheduler
de: Heuristik für letzte Befehle im Planer einschalten

en: Enable the normal mode
de: Normalen Modus einschalten

en: Enable the rank heuristic in the scheduler
de: Rang-Heuristik im Planer einschalten

en: Enable the speculative instruction heuristic in the scheduler
de: Heuristik für spekulative Befehle im Planer einschalten

en: Enable the use of 64-bit floating point registers in fmov instructions.  See -mdalign if 64-bit alignment is required.
de: Verwendung von 64-Bit Gleitkommaregistern in FMOV-Befehlen aktivieren. Siehe auch -mdalign, wenn 64-Bit-Ausrichtung benötigt wird.

en: Enable the use of RX FPU instructions.  This is the default.
de: Verwendung des RX-FPU-Befehls einschalten. Dies ist Standard.

en: Enable the use of the fused floating point multiply-accumulate operation
de: Verwendung der verschmolzenen Gleitkommabefehle zum Multiplizieren/Addieren einschalten

en: Enable the use of the indexed addressing mode for SHmedia32/SHcompact
de: Verwendung des indizierten Addressierungsmodus für SHmedia32/SHcompact einschalten

en: Enable the use of the short load instructions
de: Verwendung der kurzen Ladebefehle einschalten

en: Enable traditional preprocessing
de: Traditionelle Vorverarbeitung einschalten

en: Enable unaligned load/store instruction
de: Unausgerichtete Load/Store-Befehle einschalten

en: Enable use of GPREL for read-only data in FDPIC
de: Verwendung von GPREL für Nur-Lese-Daten in FDPIC einschalten

en: Enable use of cost model in vectorization
de: Verwendung des Kostenmodells in Vektorisierung einschalten

en: Enable use of sdata/scommon/sbss
de: Verwendung von sdata/scommon/sbss einschalten

en: Enable user-defined instructions
de: Benutzerdefinierte Befehle einschalten

en: Enable verbose output
de: Wortreiche Ausgabe einschalten

en: Enable/Disable the traditional scheduling in loops that already passed modulo scheduling
de: Traditionelle Planung in Schleifen, die bereits Modulo-Planung unterzogen wurden, einschalten/ausschalten

en: Enabled ID based shared library
de: ID-basierte Shared Library einschalten

en: Enables a register move optimization
de: Eine Registerbewegungsoptimierung einschalten

en: Encode SSE instructions with VEX prefix
de: SSE-Befehle mit VEX-Präfix kodieren

en: End expression in DO loop
de: End-Ausdruck in DO-Schleife

en: End of nonblock DO statement at %C is interwoven with another DO loop
de: Ende der DO-Anweisung bei %C ist mit anderer DO-Schleife verwoben

en: End of nonblock DO statement at %C is within another block
de: Ende der DO-Anweisung ohne Block bei %C ist innerhalb eines anderen Blockes

en: End of search list.
de: Ende der Suchliste.

en: Enforce class member access control semantics
de: Semantik der Zugriffskontrolle für Klassenelemente erzwingen

en: Entity '%s' at %C is already present in the interface
de: Entität »%s« bei %C ist bereits in der Schnittstelle vorhanden

en: Entity with assumed character length at %L must be a dummy argument or a PARAMETER
de: Entität mit vermuteter Zeichenlänge bei %L muss ein Scheinargument oder ein PARAMETER sein

en: Enumerator exceeds the C integer type at %C
de: Zähler übersteigt den C-Ganzzahltyp bei %C

en: Equivalence for '%s' does not match ordering of COMMON '%s' at %L
de: Äquivalenz für »%s« passt nicht zur Anordnung von COMMON »%s« bei %L

en: Error converting PARAMETER constant in complex constant at %C
de: Fehler bei Umwandlung von PARAMETER-Konstante in komplexer Konstante bei %C

en: Error converting integer
de: Fehler beim Umwandeln einer Ganzzahl

en: Error count reached limit of %d.
de: Fehlerzahl erreichte Grenze %d.

en: Error in pointer initialization at %C
de: Fehler in Zeigerinitialisierung bei %C

en: Error writing module file '%s' for writing: %s
de: Fehler beim Schreiben der Moduldatei »%s«: %s

en: Error writing modules file: %s
de: Fehler beim Schreiben der Moduldatei: %s

en: Error:
de: Fehler:

en: Event
de: Ereignis

en: Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression
de: Abbruchbedingung der DO WHILE-Schleife bei %L muss ein skalarer LOGICAL-Ausdruck sein

en: Exit on the first error occurred
de: Beim ersten auftretenden Fehler beenden

en: Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check
de: 32-/64-Bit Ganzzahldivision in vorzeichenlose 8-Bit Ganzzahldivision mit Laufzeitprüfung erweitern

en: Expected ")" at %C
de: »)« bei %C erwartet

en: Expected "," at %C
de: »,« bei %C erwartet

en: Expected "," or end of statement at %C
de: »,« oder Ende der Anweisung bei %C erwartet

en: Expected '(' at %C
de: »(« bei %C erwartet

en: Expected '::' after binding-attributes at %C
de: »::« nach Bindeattributen bei %C erwartet

en: Expected '::' at %C
de: »::« bei %C erwartet

en: Expected '=>' at %C
de: »=>« bei %C erwartet

en: Expected 'END INTERFACE ASSIGNMENT (=)' at %C
de: »END INTERFACE ASSIGNMENT (=)« bei %C erwartet

en: Expected :: in TYPE definition at %C
de: »::« in TYPE-Definition bei %C erwartet

en: Expected = sign in PARAMETER statement at %C
de: Zeichen »=« in PARAMETER-Anweisung bei %C erwartet

en: Expected P edit descriptor
de: P-Edit-Deskriptor erwartet

en: Expected PARAMETER symbol in complex constant at %C
de: PARAMETER-Symbol in komplexer Konstante bei %C erwartet

en: Expected a CASE or END SELECT statement following SELECT CASE at %C
de: CASE- oder END-SELECT-Anweisung hinter SELECT CASE bei %C erwartet

en: Expected a PURE procedure for argument '%s' at %L
de: PURE-Prozedur für Argument »%s« bei %L erwartet

en: Expected a nameless interface at %C
de: Namenlose Schnittstelle bei %C erwartet

en: Expected a procedure for argument '%s' at %L
de: Prozedur für Argument »%s« bei %L erwartet

en: Expected a right parenthesis in expression at %C
de: Rechte Klammer in Ausdruck bei %C erwartet

en: Expected a step value in iterator at %C
de: Schrittvariable in Iterator bei %C erwartet

en: Expected access-specifier at %C
de: Zugriffsspezifikation bei %C erwartet

en: Expected alternate return label at %C
de: Alternative Rücksprungmarke bei %C erwartet

en: Expected an initialization expression at %C
de: Initialisierungsausdruck bei %C erwartet

en: Expected another dimension in array declaration at %C
de: Andere Dimension in Felddeklaration bei %C erwartet

en: Expected array subscript at %C
de: Feldindex erwartet bei %C

en: Expected array subscript stride at %C
de: Feldindexsprung erwartet bei %C

en: Expected attribute bit name
de: Attributbitname erwartet

en: Expected binding attribute at %C
de: Bindeattribut bei %C erwartet

en: Expected binding name at %C
de: Bindungsname bei %C erwartet

en: Expected binding target after '=>' at %C
de: Bindungsziel hinter »=>« bei %C erforderlich

en: Expected block name of '%s' in %s statement at %C
de: Blocknamen von »%s« in %s-Anweisung bei %C erwartet

en: Expected coarray variable as '%s' argument to the %s intrinsic at %L
de: Coarray-Variable als Argument '%s' für intrinsisches %s bei %L erwartet

en: Expected comma in I/O list at %C
de: Komma in E/A-Liste bei %C erwartet

en: Expected exponent in expression at %C
de: Exponent in Ausdruck bei %C erwartet

en: Expected expression at %C in PARAMETER statement
de: Ausdruck bei %C in PARAMETER-Anweisung erwartet

en: Expected expression in %s statement at %C
de: Ausdruck in %s-Anweisung bei %C erwartet

en: Expected expression in array specification at %C
de: Erwarteter Ausdruck in Feldspezifikation bei %C

en: Expected expression type
de: Ausdruckstyp erwartet

en: Expected formal argument list in function definition at %C
de: Formale Argumentliste in Funktionsdefinition bei %C erwartet

en: Expected generic name or operator descriptor at %C
de: Generischer Name oder Operatordeskriptor bei %C erwartet

en: Expected initialization expression at %C
de: Initialisierungsausdruck bei %C erwartet

en: Expected initialization expression in CASE at %C
de: Erwarteter Initialisierungsausdruck in CASE bei %C

en: Expected integer
de: Ganzzahl erwartet

en: Expected integer string
de: Ganzzahlzeichenkette erwartet

en: Expected label '%s' for %s statement at %C
de: Marke »%s« für %s-Anweisung bei %C erwartet

en: Expected left parenthesis
de: Linke Klammer erwartet

en: Expected name
de: Name erwartet

en: Expected real string
de: Echte Zeichenkette erwartet

en: Expected right parenthesis
de: Rechte Klammer erwartet

en: Expected scalar initialization expression at %C
de: Skalaren Initialisierungsausdruck bei %C erwartet

en: Expected specific binding name at %C
de: Spezifischer Bindungsname bei %C erwartet

en: Expected string
de: Zeichenkette erwartet

en: Expected structure component name at %C
de: Strukturkomponentenname bei %C erwartet

en: Expected terminating name at %C
de: Beendenden Namen bei %C erwartet

en: Expected variable in READ statement at %C
de: Variable in READ-Anweisung bei %C erwartet

en: Expected variable name at %C
de: Variablennamen bei %C erwartet

en: Expected variable name at %C in PARAMETER statement
de: Variablennamen bei %C in PARAMETER-Anweisung erwartet

en: Expecting %s statement at %C
de: %s-Anweisung bei %C erwartet

en: Expecting 'END INTERFACE %s' at %C
de: »END INTERFACE %s« bei %C erwartet

en: Expecting 'END INTERFACE OPERATOR (.%s.)' at %C
de: »END INTERFACE OPERATOR (.%s.)« bei %C erwartet

en: Expecting list of named entities at %C
de: Liste benannter Einträge bei %C erwartet

en: Export functions even if they can be inlined
de: Funktionen exportieren, auch wenn sie »inline« sein können

en: Expression at %L in this context must be constant
de: Ausdruck bei %L muss in diesem Kontext eine Konstante sein

en: Expression at %L must be scalar
de: Ausdruck bei %L muss skalar sein

en: Expression in CASE statement at %L must be of type %s
de: Ausdruck in CASE-Anweisung bei %L muss Typ %s haben

en: Expression in CASE statement at %L must be scalar
de: Ausdruck in CASE-Anweisung bei %L muss skalar sein

en: Extension: %s specifier in %s statement at %C has value '%s'
de: Erweiterung: Spezifizierer %s in Anweisung %s bei %C hat Wert »%s«

en: Extension: BOZ constant at %C uses non-standard postfix syntax
de: Erweiterung: BOZ-Konstante bei %C verwendet Nicht-Standard-Postfix-Syntax

en: Extension: BOZ literal at %L outside a DATA statement and outside INT/REAL/DBLE/CMPLX
de: Erweiterung: BOZ-Literal bei %L außerhalb einer DATA-Anweisung und außerhalb von INT/REAL/DBLE/CMPLX

en: Extension: BOZ literal at %L used to initialize non-integer variable '%s'
de: Erweiterung: BOZ-Literal bei %L verwendet, um Nicht-Ganzzahlvariable »%s« zu initialisieren

en: Extension: BYTE type at %C
de: Erweiterung: BYTE-Typ bei %C

en: Extension: CONVERT tag at %L
de: Erweiterung: CONVERT-Marke bei %L

en: Extension: Conversion from %s to %s at %L
de: Erweiterung: Umwandlung von %s in %s bei %L

en: Extension: DOUBLE COMPLEX at %C
de: Erweiterung: DOUBLE COMPLEX bei %C

en: Extension: Different type kinds at %L
de: Erweiterung: Verschiedene Typ-Arten bei %L

en: Extension: Evaluation of nonstandard initialization expression at %L
de: Erweiterung: Auswertung des nicht standardisierten Initialisierungsausdrucks bei %L

en: Extension: Function %s at %L with entries returning variables of different string lengths
de: Erweiterung: Funktion %s bei %L mit Einträgen, die Variablen mit verschiedenen Zeichenkettenlängen zurückgeben

en: Extension: Hexadecimal constant at %C uses non-standard syntax
de: Erweiterung: Hexadezimalkonstante bei %C verwendet Nicht-Standard-Syntax

en: Extension: Hollerith constant at %C
de: Erweiterung: Hollerithkonstante bei %C

en: Extension: Negative argument N at %L
de: Erweiterung: Negatives Argument N bei %L

en: Extension: Non-character in FORMAT tag at %L
de: Erweiterung: Nicht-Zeichen in FORMAT-Markierung bei %L

en: Extension: Old-style initialization at %C
de: Erweiterung: Initialisierung im alten Stil bei %C

en: Extension: REAL array index at %L
de: Erweiterung: REAL-Feld-Index bei %L

en: Extension: RETURN statement in main program at %C
de: Erweiterung: RETURN-Anweisung im Hauptprogramm bei %C

en: Extension: Tab character in format at %C
de: Erweiterung: Tab-Zeichen im Format bei %C

en: Extension: Unary operator following arithmetic operator (use parentheses) at %C
de: Erweiterung: Unärer Operator hinter arithmetischem Operator bei %C (Klammern verwenden)

en: Extension: argument list function at %C
de: Erweiterung: Argumentlistenfunktion bei %C

en: Extension: backslash character at %C
de: Erweiterung: Zeichen Backslash bei %C

en: Extension: initialization of common block variable '%s' in DATA statement at %C
de: Erweiterung: Initialisierung der allgemeinen Blockvariable »%s« in DATA-Anweisung bei %C

en: Extension: re-initialization of '%s' at %L
de: Erweiterung: Reinitialisierung von »%s« bei %L

en: External '%s' at %L cannot have an initializer
de: Externes »%s« bei %L kann keine Initialisierung haben

en: External IO UNIT cannot be an array at %L
de: Externe IO UNIT kann kein Feld bei %L sein

en: External object '%s' at %L may not have an initializer
de: Externes Objekt »%s« bei %L darf keine Initialisierung haben

en: FINAL declaration at %C must be inside a derived type CONTAINS section
de: FINAL-Deklaration bei %C muss innerhalb eines CONTAINS-Abschnitts eines abgeleiteten Typs stehen

en: FORALL end expression at %L must be a scalar INTEGER
de: FORALL-Endausdruck bei %L muss skalarer INTEGER sein

en: FORALL index '%s' may not appear in triplet specification at %L
de: FORALL-Index »%s« kann nicht in Tripel-Spezifikation bei %L auftreten

en: FORALL index-name at %L must be a scalar INTEGER
de: FORALL-Indexname bei %L muss skalarer INTEGER sein

en: FORALL start expression at %L must be a scalar INTEGER
de: FORALL-Anfangsausdruck bei %L muss skalarer INTEGER sein

en: FORALL stride expression at %L cannot be zero
de: FORALL-Schrittausdruck bei %L kann nicht Null sein

en: FORALL stride expression at %L must be a scalar %s
de: FORALL-Schrittausdruck bei %L muss skalares %s sein

en: FORMAT label %d at %L not defined
de: FORMAT-Marke %d bei %L nicht definiert

en: FORMAT statement at %L does not have a statement label
de: FORMAT-Anweisung bei %L hat keine Anweisungsmarke

en: FORMAT tag at %L must be of type CHARACTER or INTEGER
de: FORMAT-Markierung bei %L muss vom Typ CHARACTER oder INTEGER sein

en: FP exceptions are enabled
de: Gleitkomma-Ausnahmen sind eingeschaltet

en: FPA is unsupported in the AAPCS
de: FPA wird im AAPCS nicht unterstützt

en: FUNCTION result %s can't be a POINTER in FUNCTION %s at %L
de: FUNCTION-Ergebnis %s kann kein POINTER in FUNCTION %s bei %L sein

en: FUNCTION result %s can't be an array in FUNCTION %s at %L
de: FUNCTION-Ergebnis %s kann kein Feld in FUNCTION %s bei %L sein

en: FUNCTION result %s can't be of type %s in FUNCTION %s at %L
de: FUNCTION-Ergebnis %s kann nicht vom Typ %s in FUNCTION %s bei %L sein

en: Failed to open file %s for writing state: %s
de: Datei %s konnte nicht zum Schreiben des Zustands geöffnet werden: %s

en: Failed to open state file %s for reading [%s]
de: Zustandsdatei %s konnte nicht zum Lesen geöffnet werden [%s]

en: Fatal Error:
de: Schwerwiegender Fehler:

en: File '%s' opened at %C is not a GFORTRAN module file
de: Bei %2$C geöffnete Datei »%1$s« ist keine GFORTRAN-Moduldatei

en: First argument of operator interface at %L cannot be optional
de: Erstes Argument der Operatorschnittstelle bei %L kann nicht optional sein

en: First argument of operator interface at %L must be INTENT(IN)
de: Erstes Argument der Operatorschnittstelle bei %L muss INTENT(IN) sein

en: First or last !$OMP ATOMIC intrinsic argument must be '%s' at %L
de: Erstes oder letztes !$OMP ATOMIC intrinsisches Argument muss bei %2$L »%1$s« sein

en: Fixed line length must be at least seven.
de: Feste Zeilenlänge muss mindestens sieben sein.

en: Flag -fmax-stack-var-size=%d overwrites -frecursive implied by -fopenmp
de: Schalter -fmax-stack-var-size=%d überschreibt -frecursive (ausgelöst durch -fopenmp)

en: Flag -fno-automatic overwrites -fmax-stack-var-size=%d
de: Schalter -fno-automatic überschreibt -fmax-stack-var-size=%d

en: Flag -fno-automatic overwrites -frecursive
de: Schalter -fno-automatic überschreibt -frecursive

en: Flag -fno-automatic overwrites -frecursive implied by -fopenmp
de: Schalter -fno-automatic überschreibt -frecursive (ausgelöst durch -fopenmp)

en: Flag -frecursive overwrites -fmax-stack-var-size=%d
de: Schalter -frecursive überschreibt -fmax-stack-var-size=%d

en: Floating point unit does not support divide & sqrt
de: Gleitkommaeinheit unterstützt nicht Division und Quadratwurzel

en: Follow Renesas (formerly Hitachi) / SuperH calling conventions
de: Renesas(vormals Hitachi)/SuperH-Aufrufkonventionen folgen

en: Follow the EABI linkage requirements
de: Den EABI Bindeanforderungen folgen

en: For bug reporting instructions, please see:
    %s.
de: Zum Einsenden von Fehlerberichten (auf Englisch) siehe:
    %s.
    Fehler in der deutschen Übersetzung sind an
    translation-team-de@lists.sourceforge.net zu melden.

en: For dummy procedure %s, no binding name is allowed in BIND(C) at %C
de: For Schein-Prozedur %s in BIND(C) bei %C ist kein bindender Name erlaubt

en: For intrinsics library: pass all parameters in registers
de: Für Intrinsics-Bibliothek: alle Parameter in Registern übergeben

en: For nested functions on stack executable permission is set.
de: Für geschachtelte Funktionen auf dem Stack werden Ausführrechte gesetzt.

en: Force bitfield accesses to match their type width
de: Bitfeld-Zugriffe zwingen, zu ihrer Typbreite zu passen

en: Force functions to be aligned to a 4 byte boundary
de: Funktionen auf 4-Byte-Grenzen zwingen

en: Force the underlying type for "wchar_t" to be "unsigned short"
de: Den für »wchar_t« zugrundeliegenden Typen auf »unsigned short« zwingen

en: Format statement in module main block at %C
de: Formatanweisung im Hauptblock des Modules bei %C

en: Fortran 2003: "USE :: module" at %C
de: Fortran 2003: "USE :: module" bei %C

en: Fortran 2003: %s attribute with %s attribute at %L
de: Fortran 2003: Attribut %s mit Attribut %s bei %L

en: Fortran 2003: %s attribute with %s attribute in '%s' at %L
de: Fortran 2003: Attribut %s mit Attribut %s in »%s« bei %L

en: Fortran 2003: %s specifier in %s statement at %C has value '%s'
de: Fortran 2003: Spezifizierer %s in Anweisung %s bei %C hat Wert »%s«

en: Fortran 2003: '%s' intrinsic with CHARACTER argument at %L
de: Fortran 2003: intrinsisches »%s« mit CHARACTER-Argument bei %L

en: Fortran 2003: '%s' intrinsic with KIND argument at %L
de: Fortran 2003: intrinsisches »%s« mit KIND-Argument bei %L

en: Fortran 2003: '%s' is of a PRIVATE type and cannot be a dummy argument of '%s', which is PUBLIC at %L
de: Fortran 2003: »%s« hat PRIVATE-Typ und kann kein Scheinargument von »%s« sein, das PUBLIC bei %L ist

en: Fortran 2003: ABSTRACT INTERFACE at %C
de: Fortran 2003: ABSTRACT INTERFACE bei %C

en: Fortran 2003: ABSTRACT type at %C
de: Fortran 2003: ABSTRACT-Typ bei %C

en: Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition
de: Fortran 2003: Attribut ALLOCATABLE bei %C in einer TYPE-Definition

en: Fortran 2003: ASYNCHRONOUS attribute at %C
de: Fortran 2003: ASYNCHRONOUS-Attribut bei %C

en: Fortran 2003: ASYNCHRONOUS statement at %C
de: Fortran 2003: ASYNCHRONOUS-Anweisung bei %C

en: Fortran 2003: Array constructor including type specification at %C
de: Fortran 2003: Feldkonstruktor mit Typspezifikation bei %C

en: Fortran 2003: Attribute %s at %L in a TYPE definition
de: Fortran 2003: Attribut %s bei %L in einer TYPE-Definition

en: Fortran 2003: BIND(C) at %L
de: Fortran 2003: BIND(C) bei %L

en: Fortran 2003: BOZ used outside a DATA statement at %C
de: Fortran 2003: BOZ außerhalb einer DATA-Anweisung bei %C verwendet

en: Fortran 2003: CLASS statement at %C
de: Fortran 2003: CLASS-Anweisung bei %C

en: Fortran 2003: COMMON block '%s' at %L that is also a function result
de: Fortran 2003: COMMON-Block »%s« bei %L der auch ein Funktionsergebnis ist

en: Fortran 2003: COMMON block '%s' at %L that is also a global procedure
de: Fortran 2003: COMMON-Block »%s« bei %L der auch eine globale Prozedur ist

en: Fortran 2003: Derived type definition at %C without components
de: Fortran 2003: Definition des abgeleiteten Typs bei %C ohne Komponenten

en: Fortran 2003: ENUM and ENUMERATOR at %C
de: Fortran 2003: ENUM AND ENUMERATOR bei %C

en: Fortran 2003: EXTENDS at %L
de: Fortran 2003: EXTENDS bei %L

en: Fortran 2003: Elemental function as initialization expression with non-integer/non-character arguments at %L
de: Fortran 2003: Elementare Funktion als Initialisierungsausdruck mit Nicht-Ganzzahl-/Nicht-Zeichen-Argumenten bei %L

en: Fortran 2003: FLUSH statement at %C
de: Fortran 2003: FLUSH-Anweisung bei %C

en: Fortran 2003: Function '%s' as initialization expression at %L
de: Fortran 2003: Funktion »%s« als Initialisierungsausdruck bei %L

en: Fortran 2003: IMPORT statement at %C
de: Fortran 2003: IMPORT-Anweisung bei %C

en: Fortran 2003: IOMSG tag at %L
de: Fortran 2003: IOMSG-Markierung bei %L

en: Fortran 2003: ISO_C_BINDING module at %C
de: Fortran 2003: Modul ISO_C_BINDING bei %C

en: Fortran 2003: ISO_FORTRAN_ENV intrinsic module at %C
de: Fortran 2003: Intrinsisches Modul ISO_FORTRAN_ENV bei %C

en: Fortran 2003: Internal file at %L with namelist
de: Fortran 2003: Interne Datei bei %L mit Namensliste

en: Fortran 2003: NAMELIST array object '%s' with assumed shape in namelist '%s' at %L
de: Fortran 2003: NAMELIST-Feldobjekt »%s« mit vermuteter Form in Namensliste »%s« bei %L

en: Fortran 2003: NAMELIST array object '%s' with nonconstant shape in namelist '%s' at %L
de: Fortran 2003: NAMELIST-Feldobjekt »%s« ohne konstante Form in Namensliste »%s« bei %L

en: Fortran 2003: NAMELIST object '%s' in namelist '%s' at %L with ALLOCATABLE or POINTER components
de: Fortran 2003: NAMELIST-Objekt »%s« in Namensliste »%s« bei %L mit ALLOCATABLE- oder POINTER-Komponenten

en: Fortran 2003: NAMELIST object '%s' with nonconstant character length in namelist '%s' at %L
de: Fortran 2003: NAMELIST-Objekt »%s« ohne konstante Zeichenlänge in Namensliste »%s« bei %L

en: Fortran 2003: Noninteger exponent in an initialization expression at %L
de: Fortran 2003: Nichtganzzahliger Exponent in einem Initialisierungsausdruck bei %L

en: Fortran 2003: PARAMETER symbol in complex constant at %C
de: Fortran 2003: PARAMETER-Symbol in komplexer Konstante bei %C

en: Fortran 2003: PROCEDURE statement at %C
de: Fortran 2003: PROCEDURE-Anweisung bei %C

en: Fortran 2003: PROTECTED attribute at %C
de: Fortran 2003: PROTECTED-Attribut bei %C

en: Fortran 2003: PROTECTED statement at %C
de: Fortran 2003: PROTECTED-Anweisung bei %C

en: Fortran 2003: PUBLIC %s '%s' at %L of PRIVATE derived type '%s'
de: Fortran 2003: PUBLIC %s »%s« bei %L mit abgeleitetem PRIVATE-Typen »%s«

en: Fortran 2003: PUBLIC function '%s' at %L of PRIVATE type '%s'
de: Fortran 2003: PUBLIC-Funktion »%s« bei %L mit PRIVATE-Typen »%s«

en: Fortran 2003: Procedure '%s' in PUBLIC interface '%s' at %L takes dummy arguments of '%s' which is PRIVATE
de: Fortran 2003: Prozedur »%s« in PUBLIC-Schnittstelle »%s« bei %L nimmt Schneinargumente von »%s«, das PRIVATE ist

en: Fortran 2003: Procedure pointer at %C
de: Fortran 2003: Prozedur-Zeiger bei %C

en: Fortran 2003: Procedure pointer component at %C
de: Fortran 2003: Prozedurzeiger-Komponente bei %C

en: Fortran 2003: Renaming operators in USE statements at %C
de: Fortran 2003: Umbenennungsoperatoren in USE-Anweisungen bei %C

en: Fortran 2003: Scalar CHARACTER actual argument with array dummy argument '%s' at %L
de: Fortran 2003: Skalares effektives CHARACTER-Argument mit Feld-Scheinargument »%s« bei %L

en: Fortran 2003: VALUE attribute at %C
de: Fortran 2003: VALUE-Attribut bei %C

en: Fortran 2003: VALUE statement at %C
de: Fortran 2003: VALUE-Anweisung bei %C

en: Fortran 2003: VOLATILE attribute at %C
de: Fortran 2003: VOLATILE-Attribut bei %C

en: Fortran 2003: VOLATILE statement at %C
de: Fortran 2003: VOLATILE-Anweisung bei %C

en: Fortran 2003: [...] style array constructors at %C
de: Fortran 2003: Feldkonstruktoren im [...]-Stil bei %C

en: Fortran 2003: deferred type parameter at %C
de: Fortran 2003: Parameter mit zurückgestelltem Typ bei %C

en: Fortran 2003: module nature in USE statement at %C
de: Fortran 2003: Modul-Eigenschaft in USE-Anweisung bei %C

en: Fortran 2008 obsolescent feature: ENTRY statement at %C
de: Fortran 2008: Veraltete Funktion: ENTRY-Anweisung bei %C

en: Fortran 2008: '%s' intrinsic with RADIX argument at %L
de: Fortran 2008: intrinsisches »%s« mit RADIX-Argument bei %L

en: Fortran 2008: Array specification at %C with more than 7 dimensions
de: Fortran 2008: Feldspezifikation bei %C mit mehr als 7 Dimensionen

en: Fortran 2008: BIND(C) attribute at %L may not be specified for an internal procedure
de: Fortran 2008: BIND(C)-Attribut bei %L kann nicht für eine interne Prozedur angegeben werden

en: Fortran 2008: COMPLEX argument '%s' argument of '%s' intrinsic at %L
de: Fortran 2008: COMPLEX-Argument »%s« des intrinsischen »%s« bei %L

en: Fortran 2008: CONTIGUOUS attribute at %C
de: Fortran 2008: CONTIGUOUS-Attribut bei %C

en: Fortran 2008: CONTIGUOUS statement at %C
de: Fortran 2008: CONTIGUOUS-Anweisung bei %C

en: Fortran 2008: Coarray declaration at %C
de: Fortran 2008: Coarray-Deklaration bei %C

en: Fortran 2008: END statement instead of %s statement at %L
de: Fortran 2008: END-Anweisung statt %s-Anweisung bei %L

en: Fortran 2008: IMPURE procedure at %C
de: Fortran 2008: IMPURE-Prozedur bei %C

en: Fortran 2008: Implied-shape array at %L
de: Fortran 2008: Feld mit impliziter Form bei %L

en: Fortran 2008: PROCEDURE list at %C
de: Fortran 2008: PROCEDURE-Liste bei %C

en: Fortran 2008: SELECTED_REAL_KIND with neither 'P' nor 'R' argument at %L
de: Fortran 2008: SELECTED_REAL_KIND ohne Argument »P« oder »R« bei %L

en: Fortran 2008: TYPE with intrinsic-type-spec at %C
de: Fortran 2008: TYPE mit intrinsischer Typspezifikation bei %C

en: Fortran 2008: double colon in MODULE PROCEDURE statement at %L
de: Fortran 2008: »::« in MODULE PROCEDURE-Anweisung bei %L

en: Fortran 2008: non-NULL pointer initialization at %C
de: Fortran 2008: Nicht-NULL-Zeigerinitialisierung bei %C

en: Fortran 95 requires default INTEGER in %s tag at %L
de: Fortran 95 erfordert Standard INTEGER in %s-Marke bei %L

en: Free line length must be at least three.
de: Freie Zeilenlänge muss mindestens drei sein.

en: Function %s at %L has entries with mismatched array specifications
de: Funktion %s bei %L hat Einträge mit unpassenden Feldspezifikationen

en: Function '%s' at %L cannot have an initializer
de: Funktion »%s« bei %L kann keine Initialisierung haben

en: Function '%s' at %L has no IMPLICIT type
de: Funktion »%s« bei %L hat IMPLICIT-Typ

en: Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic
de: Funktion »%s« bei %L ist INTRINSIC, aber nicht mit eingebauter Funktion verträglich

en: Function '%s' at %L must be PURE
de: Funktion »%s« bei %L muss PURE sein

en: Function '%s' is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument
de: Funktion »%s« ist als CHARACTER(*) deklariert und kann nicht bei %L verwendet werden, da es kein Scheinargument ist

en: Function '%s' requires an argument list at %C
de: Funktion »%s« erfordert eine Argumentliste bei %C

en: Function name '%s' not allowed at %C
de: Funktionsname »%s« nicht erlaubt bei %C

en: Function reference to '%s' at %L is to a non-PURE procedure within a PURE procedure
de: Funktionsreferenz auf »%s« bei %L ist Nicht-PURE-Prozedur innerhalb einer PURE-Prozedur

en: Function result '%s' at %L cannot have an initializer
de: Funktionsergebnis »%s« bei %L kann keine Initialisierung haben

en: Function result '%s' at %L has no IMPLICIT type
de: Funktionsergebnis »%s« bei %L hat keinen IMPLICIT-Typ

en: Function result '%s' at %L shall not be a coarray or have a coarray component
de: Funktionsergebnis »%s« bei %L sollte kein Koarray sein oder Koarray-Komponente haben

en: Function starts are aligned to this power of 2
de: Funktionsanfänge werden zu dieser Zweierpotenz ausgerichtet

en: Functions which return values must end with return statements
de: Funktionen die Werte zurück geben müssen mit return-Anweisungen enden

en: GCC cannot support operators with integer types and fixed-point types that have too many integral and fractional bits together
de: GCC kann keine Operatoren mit Ganzzahl- und Festkommatypen unterstützen, die zusammen zu viele Ganzzahl- und Bruch-Bits haben

en: GCC supports only %u nested scopes
de: GCC unterstützt nur %u geschachtelte Gültigkeitsbereiche

en: GCC vector passed by reference: non-standard ABI extension with no compatibility guarantee
de: GCC-Vektor per Referenz übergegeben: Nicht-Standard-ABI-Erweiterung ohne Kompatibilitätsgarantie

en: GCC vector returned by reference: non-standard ABI extension with no compatibility guarantee
de: GCC-Vektor per Referenz zurückgegeben: Nicht-Standard-ABI-Erweiterung ohne Kompatibilitätsgarantie

en: GCSE disabled
de: GCSE ausgeschaltet

en: GENERIC at %C must be inside a derived-type CONTAINS
de: GENERIC bei %C muss innerhalb eines CONTAINS eines abgeleiteten Typs sein

en: GENERIC procedure '%s' is not allowed as an actual argument at %L
de: GENERIC-Prozedur »%s« ist bei %L nicht als effektives Argument erlaubt

en: GET uses port array index %d, which is out of range [%d..%d)
de: GET verwendet Port-Feldindex %d, was außerhalb des Wertebereiches [%d..%d) liegt

en: GMP version %s, MPFR version %s, MPC version %s
de: GMP-Version %s, MPFR-Version %s, MPC-Version %s.

en: GNU C no longer supports -traditional without -E
de: GNU C unterstützt nicht mehr -traditional ohne -E

en: GNU Fortran comes with NO WARRANTY, to the extent permitted by law.
    You may redistribute copies of GNU Fortran
    under the terms of the GNU General Public License.
    For more information about these matters, see the file named COPYING
de: GNU Fortran kommt OHNE GARANTIE, im vom Gesetz zulässigen Ausmaß.
    Sie dürfen Kopien von GNU Fortran unter
    den Bedingungen der GNU General Public License weitergeben.
    Für weitere Informationen hierüber, siehe die Datei COPYING

en: GNU Objective C no longer supports traditional compilation
de: GNU Objective C unterstützt keine traditionelle Übersetzung mehr

en: GNU extension: non double precision REAL argument to %s intrinsic at %L
de: GNU-Erweiterung: REAL-Argument ohne doppelte Genauigkeit für intrinsisches %s bei %L

en: GNU extension: non-default INTEGER kind argument to %s intrinsic at %L
de: GNU-Erweiterung: Nicht-Standard Argument der Art INTEGER für intrinsisches »%s« bei %L

en: Generate 32-bit FPU-less SHmedia code
de: FPU-freien 32-Bit SHmedia-Code erzeugen

en: Generate 32-bit SHmedia code
de: 32-Bit SHmedia-Code erzeugen

en: Generate 32-bit code
de: 32-Bit-Code erzeugen

en: Generate 32-bit offsets in switch tables
de: 32-Bit-Versatz in switch-Tabellen erzeugen

en: Generate 32bit i386 code
de: 32-Bit-i386-Code erzeugen

en: Generate 64-bit FPU-less SHmedia code
de: FPU-freien 64-Bit SHmedia-Code erzeugen

en: Generate 64-bit SHmedia code
de: 64-Bit SHmedia-Code erzeugen

en: Generate 64-bit code
de: 64-Bit-Code erzeugen

en: Generate 64bit x86-64 code
de: 64-Bit-x86-64-Code erzeugen

en: Generate APCS conformant stack frames
de: APCS-konforme Stapelrahmen erzeugen

en: Generate AT&T-style stubs for Mach-O
de: Stubs im AT&T-Stil für Mach-O erzeugen

en: Generate C header of platform-specific features
de: C-Header mit Plattform-spezifischen Merkmalen erzeugen

en: Generate Cell microcode
de: Cell-Mikrocode erzeugen

en: Generate FPU-less SHcompact code
de: FPU-freien SHcompact-Code erzeugen

en: Generate GFLOAT double precision code
de: GFLOAT Code mit doppelter Genauigkeit erzeugen

en: Generate H8/300H code
de: H8/300H-Code erzeugen

en: Generate H8S code
de: H8S-Code erzeugen

en: Generate H8S/2600 code
de: H8S/2600-Code erzeugen

en: Generate H8SX code
de: H8SX-Code erzeugen

en: Generate ILP32 code
de: ILP32-Code erzeugen

en: Generate LP64 code
de: ILP64-Code erzeugen

en: Generate MIPS16 code
de: MIPS16-Code erzeugen

en: Generate PA1.0 code
de: PA1.0-Code erzeugen

en: Generate PA1.1 code
de: PA1.1-Code erzeugen

en: Generate PA2.0 code (requires binutils 2.10 or later)
de: PA2.0-Code erzeugen (erfordert binutils 2.10 oder neuer)

en: Generate PPC750CL paired-single instructions
de: Paarweise-Einzel-Befehle für PPC750CL erzeugen

en: Generate SH1 code
de: SH1-Code erzeugen

en: Generate SH2 code
de: SH2-Code erzeugen

en: Generate SH2a FPU-less code
de: FPU-freien SH2a-Code erzeugen

en: Generate SH2e code
de: SH2e-Code erzeugen

en: Generate SH3 code
de: SH3-Code erzeugen

en: Generate SH3e code
de: SH3e-Code erzeugen

en: Generate SH4 FPU-less code
de: FPU-freien SH4-Code erzeugen

en: Generate SH4 code
de: SH4-Code erzeugen

en: Generate SH4-100 FPU-less code
de: FPU-freien SH4-100-Code erzeugen

en: Generate SH4-100 code
de: SH4-100-Code erzeugen

en: Generate SH4-200 FPU-less code
de: FPU-freien SH4-200-Code erzeugen

en: Generate SH4-200 code
de: SH4-200-Code erzeugen

en: Generate SH4-300 FPU-less code
de: FPU-freien SH4-300-Code erzeugen

en: Generate SH4-300 code
de: SH4-300-Code erzeugen

en: Generate SH4a FPU-less code
de: FPU-freien SH4a-Code erzeugen

en: Generate SH4a code
de: SH4a-Code erzeugen

en: Generate SH4al-dsp code
de: SH4al-dsp-Code erzeugen

en: Generate SHcompact code
de: SHcompact-Code erzeugen

en: Generate SPE SIMD instructions on E500
de: SPE SIMD Befehle auf E500 erzeugen

en: Generate VRSAVE instructions when generating AltiVec code
de: Beim Erzeugen von AltiVec-Code VRSAVE-Befehle erzeugen

en: Generate a #line directive pointing at the current working directory
de: Eine auf das aktuelle Verzeichnis verweisende #line-Anweisung erzeugen

en: Generate a call to abort if a noreturn function returns
de: Aufruf zum Abbruch erzeugen, wenn eine »noreturn«-Funktion zurückkehrt

en: Generate a single exit point for each function
de: Einen einzigen Austrittspunkt für jede Funktion erzeugen

en: Generate auto-inc/dec instructions
de: auto-inc/dec-Befehle erzeugen

en: Generate big endian code
de: Big-Endian-Code erzeugen

en: Generate big-endian code
de: Big-Endian-Code erzeugen

en: Generate bit instructions
de: Bit-Befehle erzeugen

en: Generate branch hints for branches
de: Sprunghinweise für Sprünge erzeugen

en: Generate call insns as indirect calls, if necessary
de: Falls nötig, Aufruf-Befehle als indirekte Aufrufe erzeugen

en: Generate checks for references to NULL
de: Prüfungen auf Referenzen auf NULL erzeugen

en: Generate cld instruction in the function prologue.
de: Im Funktionsprolog cld-Befehle erzeugen.

en: Generate code for 18 bit addressing
de: Code für 18-Bit-Adressierung erzeugen

en: Generate code for 32 bit addressing
de: Code für 32-Bit-Adressierung erzeugen

en: Generate code for GNU as
de: Code für GNU as erzeugen

en: Generate code for GNU assembler (gas)
de: Code für GNU Assembler (gas) erzeugen

en: Generate code for GNU ld
de: Code für GNU ld erzeugen

en: Generate code for GNU runtime environment
de: Code für die GNU-Laufzeitumgebung erzeugen

en: Generate code for NeXT (Apple Mac OS X) runtime environment
de: Code für die NeXT (Apple Mac OS X) Laufzeitumgebung erzeugen

en: Generate code for SH4 340 series (MMU/FPU-less)
de: Code für Serie SH4 340 erzeugen (ohne MMU/FPU)

en: Generate code for SH4 400 series (MMU/FPU-less)
de: Code für Serie SH4 400 erzeugen (ohne MMU/FPU)

en: Generate code for SH4 500 series (FPU-less).
de: Code für Serie SH4 500 erzeugen (ohne FPU)

en: Generate code for UNIX assembler
de: Code für UNIX Assembler erzeugen

en: Generate code for a 5206e
de: Code für einen 5206e erzeugen

en: Generate code for a 520X
de: Code für einen 520X erzeugen

en: Generate code for a 528x
de: Code für einen 528x erzeugen

en: Generate code for a 5307
de: Code für einen 5307 erzeugen

en: Generate code for a 5407
de: Code für einen 5407 erzeugen

en: Generate code for a 68000
de: Code für 68000 erzeugen

en: Generate code for a 68010
de: Code für 68010 erzeugen

en: Generate code for a 68020
de: Code für 68020 erzeugen

en: Generate code for a 68030
de: Code für einen 68030 erzeugen

en: Generate code for a 68040
de: Code für einen 68040 erzeugen

en: Generate code for a 68040, without any new instructions
de: Code für einen 68040 ohne neue Befehle erzeugen

en: Generate code for a 68060
de: Code für einen 68060 erzeugen

en: Generate code for a 68060, without any new instructions
de: Code für einen 68060 ohne neue Befehle erzeugen

en: Generate code for a 68302
de: Code für einen 68302 erzeugen

en: Generate code for a 68332
de: Code für einen 68332 erzeugen

en: Generate code for a 68851
de: Code für einen 68851 erzeugen

en: Generate code for a ColdFire v4e
de: Code für ColdFire v4e erzeugen

en: Generate code for a DLL
de: Code für DLL erzeugen

en: Generate code for a Fido A
de: Code für Fido A erzeugen

en: Generate code for a cpu32
de: Code für eine cpu32 erzeugen

en: Generate code for an 11/10
de: Code für 11/10 erzeugen

en: Generate code for an 11/40
de: Code für 11/40 erzeugen

en: Generate code for an 11/45
de: Code für 11/45 erzeugen

en: Generate code for big-endian
de: Code für »big-endian« erzeugen

en: Generate code for built-in atomic operations
de: Code für eingebaute atomare Operationen erzeugen

en: Generate code for darwin loadable kernel extensions
de: Code für ladbare Darwin-Kernelerweiterungen erzeugen

en: Generate code for functions even if they are fully inlined
de: Code für Funktionen erzeugen, auch wenn sie vollständig »inline« sind

en: Generate code for given CPU
de: Code für die gegebene CPU erzeugen

en: Generate code for huge switch statements
de: Code für große switch-Anweisungen erzeugen

en: Generate code for little-endian
de: Code für »little-endian« erzeugen

en: Generate code for old exec BSS PLT
de: Code für altes ausführbares BSS PLT erzeugen

en: Generate code for the Android platform.
de: Erzeugt Code für die Android-Plattform

en: Generate code for the Boehm GC
de: Code für den Boehm GC erzeugen

en: Generate code for the M*Core M210
de: Code für M*Core M210 erzeugen

en: Generate code for the M*Core M340
de: Code für M*Core M340 erzeugen

en: Generate code for the kernel or loadable kernel extensions
de: Code für ladbare Darwin-Kernelerweiterungen oder Kernel erzeugen

en: Generate code in big endian mode
de: Code im »Big Endian«-Modus erzeugen

en: Generate code in little endian mode
de: Code im »Little Endian«-Modus erzeugen

en: Generate code suitable for executables (NOT shared libs)
de: Code für ausführbare Dateien (NICHT Shared Libraries) erzeugen

en: Generate code suitable for fast turn around debugging
de: Für schnelles Debugging geeigneten Code erzeugen

en: Generate code that can be safely linked with MIPS16 code.
de: Code erzeugen, der sicher mit MIPS16-Code gebunden werden kann.

en: Generate code that can be used in SVR4-style dynamic objects
de: Code erzeugen, der in dynamischen Objekten im SVR4-Stil verwendet werden kann

en: Generate code that conforms to the given ABI
de: Code erzeugen, der zum angegebenen ABI passt

en: Generate code that uses 68881 floating-point instructions
de: Code erzeugen, der 68881-Gleitkommabefehle verwendet

en: Generate code that won't be linked against any other ID shared libraries,
de: Code erzeugen, der nicht mit anderen ID-shared Libraries gelinkt werden würde,

en: Generate code to check bounds before indexing arrays
de: Code zur Überprüfung der Grenzen vor Feldindizierung erzeugen

en: Generate code to check exception specifications
de: Code zur Überprüfung von Exception-Spezifikationen erzeugen

en: Generate code to use a non-exec PLT and GOT
de: Code erzeugen, der nicht ausführbares PLT und GOT enthält

en: Generate code which uses hardware floating point instructions
de: Code erzeugen, der Hardware-Gleitkommabefehle verwendet

en: Generate code with library calls for floating point
de: Code mit Bibliotheksaufrufen für Gleitkommaarithmetik erzeugen

en: Generate code without GP reg
de: Code ohne GP-Register erzeugen

en: Generate compile-time CFString objects
de: CFString-Objekte zum Kompilierungszeitpunkt erzeugen

en: Generate cpp defines for server IO
de: cpp-Defines für Server-IO erzeugen

en: Generate cpp defines for workstation IO
de: cpp-Defines für Workstation-IO erzeugen

en: Generate debug information in COFF format
de: Fehlersuchinformationen im COFF-Format erzeugen

en: Generate debug information in DWARF v2 (or later) format
de: Fehlersuchinformationen im DWARFv2-Format (oder neuer) erzeugen

en: Generate debug information in STABS format
de: Fehlersuchinformationen im STABS-Format erzeugen

en: Generate debug information in VMS format
de: Fehlersuchinformationen im VMS-Format erzeugen

en: Generate debug information in XCOFF format
de: Fehlersuchinformationen im XCOFF-Format erzeugen

en: Generate debug information in default extended format
de: Fehlersuchinformationen im erweiterten Standardformat erzeugen

en: Generate debug information in default format
de: Fehlersuchinformationen im Standardformat erzeugen

en: Generate debug information in extended STABS format
de: Fehlersuchinformationen im erweiterten STABS-Format erzeugen

en: Generate debug information in extended XCOFF format
de: Fehlersuchinformationen im erweiterten XCOFF-Format erzeugen

en: Generate debug information to support Identical Code Folding (ICF)
de: Fehlersuchinformationen erzeugen um Identical Code Folding (ICF) zu unterstützen

en: Generate default double-precision SH2a-FPU code
de: Standard SH2a-FPU-Code mit doppelter Genauigkeit erzeugen

en: Generate default single-precision SH2a-FPU code
de: Standard SH2a-FPU-Code mit einfacher Genauigkeit erzeugen

en: Generate default single-precision SH4 code
de: Standard SH4-Code mit einfacher Genauigkeit erzeugen

en: Generate default single-precision SH4-100 code
de: Standard SH4-100-Code mit einfacher Genauigkeit erzeugen

en: Generate default single-precision SH4-200 code
de: Standard SH4-200-Code mit einfacher Genauigkeit erzeugen

en: Generate default single-precision SH4-300 code
de: Standard SH4-300-Code mit einfacher Genauigkeit erzeugen

en: Generate default single-precision SH4a code
de: Standard SH4a-Code mit einfacher Genauigkeit erzeugen

en: Generate discontiguous stack frames
de: Nicht zusammenhängende Stack-Rahmen erzeugen

en: Generate divide results with reminder having the same sign as the divisor (not the dividend)
de: Divisionsergebnisse mit dem gleichen Vorzeichen im Übertrag wie der Divisor (nicht der Dividend) erzeugen

en: Generate fast indirect calls
de: Schnelle indirekte Aufrufe erzeugen

en: Generate floating point mathematics using given instruction set
de: Gleitkommaarithmetik mit gegebenem Befehlssatz erzeugen

en: Generate floating-point multiply-add instructions
de: Gleitkomma-Multiplizier-/Addier-Befehle erzeugen

en: Generate inline floating point division, optimize for latency
de: Eingebettete Gleitkommadivision erzeugen, auf Wartezeit optimieren

en: Generate inline floating point division, optimize for throughput
de: Eingebettete Gleitkommadivision erzeugen, auf Durchsatz optimieren

en: Generate inline integer division, optimize for latency
de: Eingebettete Ganzzahldivision erzeugen, auf Wartezeit optimieren

en: Generate inline integer division, optimize for throughput
de: Eingebettete Ganzzahldivision erzeugen, auf Durchsatz optimieren

en: Generate inline square root, optimize for latency
de: Eingebettete Quadratwurzel erzeugen, auf Wartezeit optimieren

en: Generate inline square root, optimize for throughput
de: Eingebettete Quadratwurzel erzeugen, auf Durchsatz optimieren

en: Generate instances of Class at runtime
de: Klasseninstanzen zur Laufzeit erzeugen

en: Generate isel instructions
de: isel-Befehle erzeugen

en: Generate lazy class lookup (via objc_getClass()) for use in Zero-Link mode
de: Lockeres Nachschlagen von Klassen (mit objc_getClass()) für Verwendung im Null-Verknüpfungs-Modus erzeugen

en: Generate little endian code
de: Little-Endian-Code erzeugen

en: Generate little-endian code
de: Little-Endian-Code erzeugen

en: Generate load/store multiple instructions
de: Laden/Speichern mehrerer Befehle erzeugen

en: Generate load/store with update instructions
de: Laden/Speichern mit Aktualisierungsbefehlen erzeugen

en: Generate make dependencies
de: Make-Abhängigkeiten werden erstellt

en: Generate make dependencies and compile
de: Make-Abhängigkeiten erzeugen und übersetzen

en: Generate normal-mode code
de: Code im normalen Modus erzeugen

en: Generate only single-precision SH2a-FPU code
de: SH2a-FPU-Code nur mit einfacher Genauigkeit erzeugen

en: Generate only single-precision SH4 code
de: SH4-Code nur mit einfacher Genauigkeit erzeugen

en: Generate only single-precision SH4-100 code
de: SH4-100-Code nur mit einfacher Genauigkeit erzeugen

en: Generate only single-precision SH4-200 code
de: SH4-200-Code nur mit einfacher Genauigkeit erzeugen

en: Generate only single-precision SH4-300 code
de: SH4-300-Code nur mit einfacher Genauigkeit erzeugen

en: Generate only single-precision SH4a code
de: SH4a-Code nur mit einfacher Genauigkeit erzeugen

en: Generate pc-relative code
de: PC-relativen Code erzeugen

en: Generate phony targets for all headers
de: Unechte Ziele für alle Headers erzeugen

en: Generate position-independent code for executables if possible (large mode)
de: Wenn möglich, lageunabhängigen Code für ausführbare Dateien erzeugen (large mode)

en: Generate position-independent code for executables if possible (small mode)
de: Wenn möglich, positionsunabhängigen Code für ausführbare Dateien erzeugen (small mode)

en: Generate position-independent code if possible (large mode)
de: Wenn möglich, lageunabhängigen Code erzeugen (large mode)

en: Generate position-independent code if possible (small mode)
de: Wenn möglich, positionsunabhängigen Code erzeugen (small mode)

en: Generate prefetch instructions, if available, for arrays in loops
de: Wenn verfügbar, Prefetch-Befehle für Felder in Schleifen erzeugen

en: Generate re-entrant, PIC code
de: Wiedereinsprungsfähigen PIC-Code erzeugen

en: Generate reciprocals instead of divss and sqrtss.
de: Reziproke statt divss und sqrtss erzeugen.

en: Generate run time type descriptor information
de: Informationen zur Typbeschreibung zur Laufzeit erzeugen

en: Generate self-relocatable code
de: Selbstverschiebbaren Code erzeugen

en: Generate sin, cos, sqrt for FPU
de: sin, cos und sqrt für FPU erzeugen

en: Generate software reciprocal divide and square root for better throughput.
de: Reziproke Division und Quadratwurzel in Software für besseren Durchsatz erzeugen.

en: Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed
de: Wenn nötig, spezielle Objective-C-Methoden zur Initialisierung/Zerstörung von nicht-POD C++ ivars, erzeugen

en: Generate string instructions for block moves
de: Zeichenkettenbefehle für Blockkopieroperationen erzeugen

en: Generate unwind tables that are exact at each instruction boundary
de: Abwicklungstabellen erzeugen, die genau an jeder Befehlsgrenze liegen

en: Generate warnings when inefficient code is known to be generated.
de: Warnen, wenn bekanntermaßen ineffizienter Code erzeugt wird.

en: Generated should be loaded by bootstrap loader
de: Generiertes sollte vom Bootstrap-Loader geladen werden

en: Generic function '%s' at %L is not consistent with a specific intrinsic interface
de: Generische Funktion »%s« bei %L ist nicht mit spezifischer intrinsischer Schnittstelle vereinbar

en: Generic subroutine '%s' at %L is not consistent with an intrinsic subroutine interface
de: Generisches Unterprogramm »%s« bei %L ist nicht mit intrinsischer Unterprogrammschnittstelle vereinbar

en: Give branches their default cost
de: Sprüngen ihre Standardkosten zuweisen

en: Give external symbols a leading underscore
de: Externen Symbolen einen führenden Unterstrich geben

en: Global name '%s' at %L is already being used as a %s at %L
de: Globaler Name »%s« bei %L wird bereits als ein %s bei %L verwendet

en: Graphite loop optimizations cannot be used
de: Graphite-Schleifenoptimierungen können nicht verwendet werden

en: Graphite loop optimizations cannot be used (-fgraphite, -fgraphite-identity, -floop-block, -floop-flatten, -floop-interchange, -floop-strip-mine, -floop-parallelize-all, and -ftree-loop-linear)
de: Graphite-Schleifenoptimierungen können nicht verwendet werden (-fgraphite, -fgraphite-identity, -floop-block, -floop-flatten, -floop-interchange, -floop-strip-mine, -floop-parallelize-all und -ftree-loop-linear)

en: Histogram value statement does not correspond to the statement it is associated with
de: Anweisung mit Histogrammwert entspricht nicht zugeordneter Anweisung

en: Host associated variable '%s' may not be in the DATA statement at %C
de: Mit Host verbundene Variable »%s« darf nicht in DATA-Anweisung bei %C stehen

en: How much can given compilation unit grow because of the inlining (in percent)
de: Wie viel die gegebene Kompilationseinheit durch das »inline« wachsen kann (in Prozent)

en: How much can given compilation unit grow because of the interprocedural constant propagation (in percent)
de: Wie viel die gegebene Kompilationseinheit durch die interprozedurale Konstantenweitergabe wachsen kann (in Prozent)

en: ICE: emit_insn used where emit_jump_insn needed:
de: ICE: emit_insn verwendet, wo emit_jump_insn erforderlich:

en: ID of shared library to build
de: ID der zu bauenden Shared Library

en: ID shared libraries and FD-PIC mode can%'t be used together
de: ID-gemeinsam genutzte Bibliotheken und FD-PIC-Modus können nicht zusammen verwendet werden

en: IF clause at %L requires a scalar LOGICAL expression
de: IF-Klausel bei %L erfordert einen skalaren LOGICAL-Ausdruck

en: IMPORT statement at %C only permitted in an INTERFACE body
de: IMPORT-Anweisung bei %C ist nur in einem INTERFACE-Körper erlaubt

en: INDIRECT_REF in gimple IL
de: INDIRECT_REF in GIMPLE-IL

en: INQUIRE statement at %L cannot contain both FILE and UNIT specifiers
de: INQUIRE-Anweisung bei %L kann nicht sowohl FILE- als auch UNIT-Spezifikationssymbole enthalten

en: INQUIRE statement at %L requires either FILE or UNIT specifier
de: INQUIRE-Anweisung bei %L erfordert entweder FILE- oder UNIT-Spezifikationssymbol

en: INQUIRE statement not allowed in PURE procedure at %C
de: INQUIRE-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: INTENT (%s) conflicts with INTENT(%s) at %L
de: INTENT(%s) steht mit INTENT(%s) bei %L in Konflikt

en: INTENT is not allowed inside of BLOCK at %C
de: INTENT ist in BLOCK bei %C nicht erlaubt

en: INTERFACE procedure '%s' at %L has the same name as the enclosing procedure
de: Schnittstellenprozedur »%s« bei %L hat den selben Namen wie die umgebende Prozedur

en: IOLENGTH tag invalid in INQUIRE statement at %C
de: IOLENGTH-Markierung in INQUIRE-Anweisung bei %C ungültig

en: ISO C does not allow extra %<;%> outside of a function
de: ISO-C erlaubt kein zusätzliches %<;%> außerhalb einer Funktion

en: ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>
de: ISO C unterstützt nicht %<#pragma STDC FLOAT_CONST_DECIMAL64%>

en: ISO C does not support %<++%> and %<--%> on complex types
de: ISO-C unterstützt kein %<++%> und %<--%> für komplexe Typen

en: ISO C does not support %<__int128%> type
de: ISO-C unterstützt nicht den Typen %<__int128%>

en: ISO C does not support %<~%> for complex conjugation
de: ISO-C unterstützt nicht %<~%> für komplexe Konjugation

en: ISO C does not support complex integer types
de: ISO-C unterstützt keine komplexen Ganzzahltypen

en: ISO C does not support decimal floating point
de: ISO-C unterstützt kein dezimales Gleitkomma

en: ISO C does not support fixed-point types
de: ISO-C unterstützt keine Ganzzahltypen

en: ISO C does not support plain %<complex%> meaning %<double complex%>
de: ISO-C unterstützt nicht %<double complex%> bedeutendes einfaches %<complex%>

en: ISO C does not support saturating types
de: ISO-C unterstützt keine sättigenden Typen

en: ISO C forbids %<goto *expr;%>
de: ISO-C verbietet %<goto *expr;%>

en: ISO C forbids %<return%> with expression, in function returning void
de: ISO-C verbietet %<return%> mit Ausdruck, in void zurückgebender Funktion

en: ISO C forbids an empty translation unit
de: ISO-C verbietet eine leere Quelldatei

en: ISO C forbids assignment between function pointer and %<void *%>
de: ISO-C verbietet Zuweisung zwischen Funktionszeiger und %<void *%>

en: ISO C forbids braced-groups within expressions
de: ISO-C verbietet geklammerte Gruppen innerhalb von Ausdrücken

en: ISO C forbids casting nonscalar to the same type
de: ISO-C verbietet Typkonvertierung von Nicht-Skalar auf selben Typen

en: ISO C forbids casts to union type
de: ISO-C verbietet Typkonvertierung auf union-Typ

en: ISO C forbids comparison of %<void *%> with function pointer
de: ISO-C verbietet Vergleich von %<void *%> mit Funktionszeiger

en: ISO C forbids conditional expr between %<void *%> and function pointer
de: ISO-C verbietet bedingten Ausdruck zwischen %<void *%> und Funktionszeiger

en: ISO C forbids conditional expr with only one void side
de: ISO-C verbietet bedingten Ausdruck mit nur einer void-Seite

en: ISO C forbids const or volatile function types
de: ISO-C verbietet const- oder volatile-Funktionstypen

en: ISO C forbids conversion of function pointer to object pointer type
de: ISO-C verbietet Konvertierung von Funktionszeigern in Objektzeigertyp

en: ISO C forbids conversion of object pointer to function pointer type
de: ISO-C verbietet Konvertierung von Objektzeigertypen in Funktionszeigertyp

en: ISO C forbids empty initializer braces
de: ISO-C verbietet leere Initialisierungsklammern

en: ISO C forbids forward parameter declarations
de: ISO-C verbietet Vorwärtsdeklaration für Parameter

en: ISO C forbids forward references to %<enum%> types
de: ISO-C verbietet Vorwärts-Referenzen auf %<enum%>-Typen

en: ISO C forbids initialization between function pointer and %<void *%>
de: ISO-C verbietet Initialisierung zwischen Funktionszeiger und %<void *%>

en: ISO C forbids label declarations
de: ISO-C verbietet Markendeklarationen

en: ISO C forbids member declarations with no members
de: ISO-C verbietet Elementdeklarationen ohne Elemente

en: ISO C forbids nested functions
de: ISO-C verbietet verschachtelte Funktionen

en: ISO C forbids omitting the middle term of a ?: expression
de: ISO-C verbietet das Weglassen des mittleren Terms eines ?:-Ausdruckes

en: ISO C forbids ordered comparisons of pointers to functions
de: ISO-C verbietet geordnete Vergleiche zwischen Zeigern auf Funktionen

en: ISO C forbids passing argument %d of %qE between function pointer and %<void *%>
de: ISO-C verbietet Übergabe des Arguments %d von %qE zwischen Funktionszeiger und %<void *%>

en: ISO C forbids qualified function types
de: ISO-C verbietet qualifizierte Funktionstypen

en: ISO C forbids return between function pointer and %<void *%>
de: ISO-C verbietet return zwischen Funktionszeiger und %<void *%>

en: ISO C forbids specifying range of elements to initialize
de: ISO-C verbietet die Angabe eines zu initialisierenden Elementebereiches

en: ISO C forbids subscripting %<register%> array
de: ISO-C verbietet, ein %<register%>-Feld zu indizieren

en: ISO C forbids zero-size array
de: ISO-C verbietet Feld der Größe null

en: ISO C forbids zero-size array %qE
de: ISO-C verbietet Feld %qE der Größe null

en: ISO C prohibits argument conversion to union type
de: ISO-C verbietet Argumentkonvertierung in union-Typ

en: ISO C requires a named argument before %<...%>
de: ISO-C erfordert ein benanntes Argument vor %<...%>

en: ISO C restricts enumerator values to range of %<int%>
de: ISO-C beschränkt Aufzählungswerte auf Bereich von %<int%>

en: ISO C++ 1998 does not support %<long long%>
de: ISO-C++ 1998 unterstützt nicht %<long long%>

en: ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations
de: ISO-C++ 1998 verbietet die Verwendung von %<extern%> bei expliziten Instanziierungen

en: ISO C++ does not allow %<alignof%> with a non-type
de: ISO-C++ erlaubt kein %<alignof%> mit einem Nicht-Typ

en: ISO C++ does not allow ?: with omitted middle operand
de: ISO-C++ erlaubt nicht ?: mit ausgelassenem mittleren Operanden

en: ISO C++ does not allow designated initializers
de: ISO-C++ erlaubt keine benannten Initialisierungen

en: ISO C++ does not allow initializers in lambda expression capture lists
de: ISO-C++ erlaubt keine Initialisierungen Auffanglisten von Lambda-Ausdrücken

en: ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>
de: ISO-C++ erlaubt nicht, %<%T::%D%> als %<%T::%D%> zu definieren

en: ISO C++ does not support %<__int128%> for %qs
de: ISO-C++ unterstützt nicht %<__int128%> for %qs

en: ISO C++ forbids applying %<__alignof%> to an expression of function type
de: ISO-C++ verbietet Anwendung von %<__alignof%> auf einen Ausdruck mit Funktionstyp

en: ISO C++ forbids applying %<sizeof%> to an expression of function type
de: ISO-C++ verbietet Anwendung von %<sizeof%> auf einen Ausdruck mit Funktionstyp

en: ISO C++ forbids braced-groups within expressions
de: ISO-C++ verbietet Gruppen in geschweiften Klammern innerhalb von Ausdrücken

en: ISO C++ forbids calling %<::main%> from within program
de: ISO-C++ verbietet den Aufruf von %<::main%> vom Programm aus

en: ISO C++ forbids casting between pointer-to-function and pointer-to-object
de: ISO-C++ verbietet Umwandlung zwischen Zeiger auf Funktion und Zeiger auf Objekt

en: ISO C++ forbids casting to an array type %qT
de: ISO-C++ verbietet Umwandlung in Feldtyp %qT

en: ISO C++ forbids comparison between pointer and integer
de: ISO-C++ verbietet Vergleich zwischen Zeiger und Ganzzahl

en: ISO C++ forbids comparison between pointer of type %<void *%> and pointer-to-function
de: ISO-C++ verbietet Vergleich zwischen Zeiger des Typs %<void *%> und Zeiger auf Funktion

en: ISO C++ forbids compound-literals
de: ISO-C++ verbietet zusammengesetzte Literale

en: ISO C++ forbids computed gotos
de: ISO-C++ verbietet berechnete Gotos

en: ISO C++ forbids conditional expression between pointer of type %<void *%> and pointer-to-function
de: ISO-C++ verbietet Bedingungsausdruck mit Zeiger des Typs %<void *%> und Zeiger auf Funktion

en: ISO C++ forbids conversion between pointer of type %<void *%> and pointer-to-function
de: ISO-C++ verbietet Umwandlung zwischen Zeiger des Typs %<void *%> und Zeiger auf Funktion

en: ISO C++ forbids declaration of %qs with no type
de: ISO-C++ verbietet Deklaration von %qs ohne Typ

en: ISO C++ forbids decrementing a pointer of type %qT
de: ISO-C++ verbietet Verringern eines Zeigers vom Typ %qT

en: ISO C++ forbids decrementing an enum
de: ISO-C++ verbietet verringern einer Aufzählung

en: ISO C++ forbids in-class initialization of non-const static member %qD
de: ISO-C++ verbietet Initialisierung des nicht konstanten statischen Elements %qD in der Klasse

en: ISO C++ forbids incrementing a pointer of type %qT
de: ISO-C++ verbietet Erhöhen eines Zeigers vom Typ %qT

en: ISO C++ forbids incrementing an enum
de: ISO-C++ verbietet erhöhen einer Aufzählung

en: ISO C++ forbids initialization in array new
de: ISO-C++ verbietet Initialisierung eines Feldes mit »new«

en: ISO C++ forbids initialization of member %qD
de: ISO-C++ verbietet Initialisierung des Elementes %qD

en: ISO C++ forbids initialization of member constant %qD of non-integral type %qT
de: ISO-C++ verbietet Initialisierung der Elementkonstante %qD vom nicht eingebauten Typen %qT

en: ISO C++ forbids nested type %qD with same name as enclosing class
de: ISO-C++ verbietet geschachtelten Typen %qD mit gleichem Namen wie umschließende Klasse

en: ISO C++ forbids omitting the middle term of a ?: expression
de: ISO-C++ verbietet das Auslassen des mittleren Terms eines »?:«-Ausdruckes

en: ISO C++ forbids subscripting non-lvalue array
de: ISO-C++ verbietet Indizierung eines Nicht-L-Wert-Feldes

en: ISO C++ forbids taking address of function %<::main%>
de: ISO-C++ verbietet das Ermitteln der Adresse der Funktion %<::main%>

en: ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>
de: ISO-C++ verbietet das Ermitteln der Adresse einer gebundenen Elementfunktion, um einen Zeiger auf Elementfunktion zu erzeugen. Stattdessen %<&%T::%D%> verwenden

en: ISO C++ forbids taking the address of a cast to a non-lvalue expression
de: ISO-C++ verbietet das Ermitteln der Adresse einer Umwandlung in einen Nicht-L-Wert-Ausdruck

en: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say %<&%T::%D%>
de: ISO-C++ verbietet das Ermitteln der Adresse einer nicht qualifizierten oder geklammerten nicht-statischen Elementfunktion, um einen Zeiger auf Elementfunktion zu erzeugen. Stattdessen %<&%T::%D%> verwenden

en: ISO C++ forbids the use of %qE on explicit instantiations
de: ISO-C++ verbietet die Verwendung von %qE bei expliziten Instanziierungen

en: ISO C++ forbids using pointer of type %<void *%> in subtraction
de: ISO-C++ verbietet die Verwendung eines Zeigers des Typs %<void *%> in Subtraktion

en: ISO C++ forbids using pointer to a function in subtraction
de: ISO-C++ verbietet die Verwendung eines Zeigers auf eine Funktion in Subtraktion

en: ISO C++ forbids using pointer to a method in subtraction
de: ISO-C++ verbietet die Verwendung eines Zeigers auf Methode in Subtraktion

en: ISO C++ forbids variable length array
de: ISO-C++ verbietet Feld variabler Länge

en: ISO C++ forbids variable length array %qD
de: ISO-C++ verbietet Feld %qD variabler Länge

en: ISO C++ forbids zero-size array
de: ISO-C++ verbietet Feld der Größe null

en: ISO C++ forbids zero-size array %qD
de: ISO-C++ verbietet Feld %qD der Größe null

en: ISO C++ prohibits anonymous structs
de: ISO-C++ verbietet anonyme structs

en: ISO C++ prohibits overloading operator ?:
de: ISO-C++ verbietet Überladen des Operators ?:

en: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
de: ISO C++ besagt, dass diese mehrdeutig sind, auch wenn die schlechteste Umwandlung für das erste besser ist als die schlechteste Umwandlung für das zweite:

en: ISO C90 does not support %<[*]%> array declarators
de: ISO-C90 unterstützt nicht %<[*]%>-Felddeklaratoren

en: ISO C90 does not support %<_Static_assert%>
de: ISO-C90 unterstützt nicht %<_Static_assert%>

en: ISO C90 does not support %<long long%>
de: ISO-C90 unterstützt nicht %<long long%>

en: ISO C90 does not support %<static%> or type qualifiers in parameter array declarators
de: ISO-C90 unterstützt kein %<static%> oder Typkennzeichner in Parameterfelddeklaratoren

en: ISO C90 does not support complex types
de: ISO-C90 unterstützt keine komplexen Typen

en: ISO C90 does not support flexible array members
de: ISO-C90 unterstützt keine flexiblen Felder als Elemente

en: ISO C90 doesn%'t support unnamed structs/unions
de: ISO-C90 unterstützt keine namenlosen structs/unions

en: ISO C90 forbids array %qE whose size can%'t be evaluated
de: ISO-C90 verbietet Feld %qE, dessen Größe nicht ausgewertet werden kann

en: ISO C90 forbids array whose size can%'t be evaluated
de: ISO-C90 verbietet Feld, dessen Größe nicht ausgewertet werden kann

en: ISO C90 forbids compound literals
de: ISO-C90 verbietet zusammengesetzte Literale

en: ISO C90 forbids mixed declarations and code
de: ISO-C90 verbietet gemischte Deklarationen und Code

en: ISO C90 forbids specifying subobject to initialize
de: ISO-C90 verbietet die Angabe von zu initialisierenden Unterobjekten

en: ISO C90 forbids subscripting non-lvalue array
de: ISO-C90 verbietet, ein Nicht-L-Wert-Feld zu indizieren

en: ISO C90 forbids variable length array
de: ISO-C90 verbietet Feld variabler Größe

en: ISO C90 forbids variable length array %qE
de: ISO-C90 verbietet Feld %qE variabler Größe

en: ISO C99 does not support %<_Static_assert%>
de: ISO-C99 unterstützt nicht %<_Static_assert%>

en: ISO C99 doesn%'t support unnamed structs/unions
de: ISO-C99 unterstützt keine namenlosen structs/unions

en: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization
de: Wenn -ftree-vectorize verwendet wird, die minimale Schleifengrenze einer für Vektorisierung zu betrachtenden Schleife

en: If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling
de: Wenn -fvariable-expansion-in-unroller verwendet wird, die Höchstzahl der Fälle, dass eine bestimmte Variable während Loop-Unrolling expandiert wird

en: If first argument of ATAN2 %L is zero, then the second argument must not be zero
de: Wenn das erste Argument von ATAN2 %L Null ist, dann darf das zweite Argument nicht Null sein

en: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization
de: Wenn die Anzahl der Kandidaten in der Menge kleiner ist, wird immer versucht, ungenutzte IVs während ihrer Optimierung zu entfernen

en: If scheduling post reload, do superblock scheduling
de: Wenn Planung nach dem Neuladen, dann Superblock-Planung

en: If set, control speculative instructions will be chosen for schedule only if there are no other choices at the moment
de: Wenn gesetzt, werden steuerungs-spekulative Anweisungen nur gewählt, wenn es es im Moment keine andere Wahl gibt

en: If set, data speculative instructions will be chosen for schedule only if there are no other choices at the moment
de: Wenn gesetzt, werden daten-spekulative Anweisungen nur gewählt, wenn es es im Moment keine andere Wahl gibt

en: Ignore 'D' in column one in fixed form
de: »D« in Spalte eins in statischer Form ignorieren

en: Ignore dllimport attribute for functions
de: Attribut dllimport für Funktionen ignorieren

en: Ignore dllimport for functions
de: dllimport für Funktionen erzeugen

en: Ignore read operations when inserting mudflap instrumentation
de: Leseoperationen ignorieren, wenn Schmutzfänger-Einsatz eingefügt wird

en: Ignored (obsolete)
de: Ignoriert (veraltet)

en: Illegal character in BOZ constant at %C
de: Unzulässiges Zeichen in BOZ-Konstante bei %C

en: Illegal reference type at %L as EQUIVALENCE object
de: Ungültiger Referenztyp bei %L als EQUIVALENCE-Objekt

en: Illegal stride of zero at %L
de: Unzulässiger Schritt von Null bei %L

en: Implicitly declared BIND(C) function '%s' at %L may not be C interoperable
de: Spezifikationsfunktion »%s« bei %L kann keine interne Funktion sein

en: Implicitly declared BIND(C) variable '%s' at %L may not be C interoperable
de: Implizit deklarierte BIND(C)-Variable »%s« bei %L kann nicht C-kompatibel sein

en: Implicitly declared variable '%s' at %L may not be C interoperable but it is a dummy argument to the BIND(C) procedure '%s' at %L
de: Implizit deklarierte Variable »%s« bei %L ist nicht C-kompatibel, sondern ein Scheinargument für BIND(C)-Prozedur »%s« bei %L

en: Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type
de: Implizit angegebener PARAMETER »%s« bei %L passt nicht zu früherem IMPLICIT-Typ

en: In %+D: overlapped variable and exception ranges at %d
de: In %+D: überlappende Variablen- und Ausnahmebereiche bei %d

en: In C++, nonzero means warn about deprecated conversion from string literals to 'char *'.  In C, similar warning, except that the conversion is of course not deprecated by the ISO C standard.
de: In C++ bedeutet ungleich Null die Warnung vor veralteter Umwandlung von Zeichenkettenliteralen in »char *«. In C erfolgt eine ähnliche Warnung, nur ist die Umwandlung nat. laut ISO-C-Standard nicht veraltet.

en: In constructor %qs
de: In Konstruktor %qs

en: In copy constructor %qs
de: In Copy-Konstruktor %qs

en: In destructor %qs
de: In Destruktor %qs

en: In function %qs
de: In Funktion %qs

en: In lambda function
de: In Lambda-Funktion

en: In member function %qs
de: In Elementfunktion %qs

en: In static member function %qs
de: In statischer Elementfunktion %qs

en: Incompatible derived type in PARAMETER at %L
de: Unverträglicher abgeleiteter Typ in PARAMETER bei %L

en: Incompatible ranks %d and %d in assignment at %L
de: Unverträgliche Ränge %d und %d in Zuweisung bei %L

en: Incompatible ranks in %s (%d and %d) at %L
de: Unverträgliche Ränge in %s (%d und %d) bei %L

en: Inconsistent equivalence rules involving '%s' at %L and '%s' at %L
de: Inkonsistente Äquivalenzregeln mit »%s« bei %L und »%s« bei %L

en: Inconsistent ranks for operator at %%L and %%L
de: Ränge für Operator bei %%L und %%L stimmen nicht überein

en: Incorrect EH edge %i->%i
de: falsche EH-Kante %i->%i

en: Incorrect function return value
de: Falscher Funktions-Rückgabewert

en: Increase the IEEE compliance for floating-point code
de: IEEE-Befolgung für Gleitkommacode erhöhen

en: Index in dimension %d is out of bounds at %L
de: Index in Dimension %d ist außerhalb der Grenzen bei %L

en: Indicate the number of soft registers available
de: Anzahl der verfügbaren Soft-Register anzeigen

en: Initialization at %C is not allowed in a PURE procedure
de: Initialisierung bei %C ist in PURE-Prozedur nicht erlaubt

en: Initialization at %C isn't for a pointer variable
de: Initialisierung bei %C ist nicht für eine Zeigervariable

en: Initialization of allocatable component at %C is not allowed
de: Initialisierung einer allozierbaren Komponente bei %C ist nicht erlaubt

en: Initialization of pointer at %C is not allowed in a PURE procedure
de: Initialisierung des Zeigers bei %C ist nicht in einer PURE-Prozedur erlaubt

en: Initialization of variable at %C is not allowed in a PURE procedure
de: Initialisierung einer Variablen bei %C ist in einer PURE-Prozedur nicht erlaubt

en: Initialization string starting at %L was truncated to fit the variable (%d/%d)
de: Initialisierungszeichenkette abgeschnitten, um an Variable bei %L anzupassen (%d/%d)

en: Initialize local variables to zero (from g77)
de: Lokale Variablen auf Null initialisieren (von g77)

en: Initialized symbol '%s' at %C can only be COMMON in BLOCK DATA
de: Initialisiertes Symbol »%s« bei %C kann nur COMMON in BLOCK DATA sein

en: Initialized variable '%s' at %L is in a blank COMMON but initialization is only allowed in named common blocks
de: Initialisierte Variable »%s« bei %L ist in leerem COMMON, aber Initialisierung ist nur in in benannten Common-Blocks erlaubt

en: Initializer not allowed for PARAMETER '%s' at %C
de: Initialisierung für PARAMETER »%s« bei %C nicht erlaubt

en: Initializing already initialized variable at %C
de: Initialisierung einer bereits initialisierten Variablen bei %C

en: Inject friend functions into enclosing namespace
de: Friend-Funktionen in umgebenden Namensraum einfügen

en: Inline all known string operations
de: Alle bekannten Zeichenkettenoperationen einbetten (inline)

en: Inline constants if it can be done in 2 insns or less
de: Konstanten einbetten, wenn es mit 2 Befehlen oder weniger geht

en: Inline memset/memcpy string operations, but perform inline version only for small blocks
de: Zeichenkettenoperationen memset/memcpy als »inline« einfügen, aber Inline-Version nur für kleine Blöcke durchführen

en: Inline recursively only when the probability of call being executed exceeds the parameter
de: Rekursives inline nur, wenn die Wahrscheinlichkeit des Aufrufs den Parameter überschreitet

en: Input file is a file with a list of filenames to compile
de: Eingabedatei ist eine Datei mit einer Liste der Dateinamen zum Übersetzen

en: Insert arc-based program profiling code
de: Arc-basierten Programm-Profilierungscode einfügen

en: Insert code to profile values of expressions
de: Code in Profilwerte von Ausdrücken einfügen

en: Insert hbrp instructions after hinted branch targets to avoid the SPU hang issue
de: HBRP-Befehle nach angedeuteten Sprungzielen einfügen, um SPU-Hängeproblem zu vermeiden

en: Insert nops when it might improve performance by allowing dual issue (default)
de: NOPs einfügen, wenn es die Leistung durch Doppelausführung erhöht (Standard)

en: Insert stack checking code into the program.  Same as -fstack-check=specific
de: Stapelprüfung in das Programm einfügen. Dasselbe wie -fstack-check=specific

en: Instrument function entry and exit with profiling calls
de: Ein- und Austritte von Funktionen beim Profilieren von Aufrufen verwenden

en: Integer expression required at %C
de: Ganzzahlausdruck erforderlich bei %C

en: Integer kind %d at %C not available
de: Ganzzahlart %d bei %C nicht verfügbar

en: Integer outside symmetric range implied by Standard Fortran at %L
de: Ganzzahl außerhalb symmetrischem Bereich wegen Standard-Fortran bei %L

en: Integer outside symmetric range implied by Standard Fortran converting %s to %s at %L
de: Ganzzahl außerhalb des symmetrischen Bereiches wegen Standard-Fortran-Konvertierung von %s in %s bei %L

en: Integer overflow
de: Ganzzahlüberlauf

en: Integer overflow when calculating the amount of memory to allocate
de: Ganzzahlüberlauf bei der Berechnung des zu reservierenden Speichers

en: Integer too big for integer kind %i at %C
de: Ganzzahl zu groß für Ganzzahlart %i bei %C

en: Integer too big for its kind at %C. This check can be disabled with the option -fno-range-check
de: Ganzzahl zu groß für ihre Art bei %C. Diese Überprüfung kann mit der Option -fno-range-check ausgeschaltet werden

en: Integer too large at %C
de: Ganzzahl bei %C zu groß

en: Integer value too large in expression at %C
de: Ganzzahlwert zu groß in Ausdruck bei %C

en: Integrate functions called once into their callers
de: Einmal aufgerufene Funktionen in ihre Aufrufer einfügen

en: Integrate simple functions into their callers
de: Einfache Funktionen in ihre Aufrufer einfügen

en: Integrate simple functions into their callers when code size is known to not growth
de: Einfache Funktionen in ihre Aufrufer einfügen, wenn Codegröße als nicht wachsend bekannt ist

en: Interface '%s' at %C may not be a statement function
de: Schnittstelle »%s« bei %C kann keine Anweisungsfunktion sein

en: Interface '%s' at %C may not be generic
de: Schnittstelle »%s« bei %C kann nicht allgemein sein

en: Interface '%s' of procedure '%s' at %L must be explicit
de: Schnittstelle »%s« der Prozedur »%s« bei %L muss explizit sein

en: Interface '%s', used by procedure '%s' at %L, is declared in a later PROCEDURE statement
de: Schnittstelle »%s«, von Prozedur »%s« bei %L verwendet, ist in späterer PROCEDURE-Anweisung deklariert

en: Interface must be specified for DEFERRED binding at %C
de: Schnittstelle muss für DEFERRED-Bindung bei %C angegeben werden

en: Interface-name expected after '(' at %C
de: Schnittstellenname nach »(« bei %C erforderlich

en: Internal Error at (1):
de: Interner Fehler bei (1):

en: Internal compiler error: Error reporting routines re-entered.
de: Interner Compilerfehler: Fehlerbehandlungsroutinen doppelt betreten.

en: Internal unit with vector subscript at %L
de: Interne Einheit mit Vektor-Index bei %L

en: Intersperse literal pools with code in the text section
de: Code in Zeichen-Daten im Text-Abschnitt einstreuen

en: Intrinsic '%s' at %L cannot have an initializer
de: Intrinsisches »%s« bei %L kann keine Initialisierung haben

en: Intrinsic '%s' at %L is not allowed as an actual argument
de: Eingebautes »%s« bei %L ist nicht als effektives Argument erlaubt

en: Intrinsic '%s' at %L must have at least two arguments
de: Das intrinsische »%s« bei %L muss mindestens zwei Argumente haben

en: Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld
de: Intrinsisches TRANSFER bei %L hat teilweise undefiniertes Ergebnis: Quellgröße %ld < Ergebnisgröße %ld

en: Intrinsic function %s(%d) not recognized
de: Innere Funktion %s(%d) nicht erkannt

en: Intrinsic function '%s' at %L is not permitted in an initialization expression
de: Intrinsische Funktion »%s« bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Intrinsic operator '%s' referenced at %L not found in module '%s'
de: Bei %2$L referenzierter intrinsischer Operator »%1$s« nicht im Modul »%3$s« gefunden

en: Intrinsic operator interface at %L must be a FUNCTION
de: Schnittstelle des intrinsischen Operators bei %L muss eine FUNCTION sein

en: Intrinsic procedure '%s' not allowed in PROCEDURE statement at %C
de: Intrinsische Prozedur »%s« ist in PROCEDURE-Anweisung bei %C nicht erlaubt

en: Intrinsic procedure at %L cannot be a MODULE PROCEDURE
de: Intrinsische Prozedur bei %L kann keine MODULE PROCEDURE sein

en: Intrinsic subroutine '%s' at %L shall not have a type specifier
de: Intrinsisches Unterprogramm »%s« bei %L sollte keine Typspezifizierung haben

en: Invalid C name in NAME= specifier at %C
de: Ungültiger C-Name in NAME=-Spezifizierung bei %C

en: Invalid Hollerith constant: %L must contain at least one character
de: Ungültige Hollerithkonstante: %L muss mindestens ein Zeichen enthalten

en: Invalid Hollerith constant: Integer kind at %L should be default
de: Ungültige Hollerithkonstante: Ganzzahlart bei %L sollte Standard sein

en: Invalid KIND parameter of %s at %L
de: Ungültiger KIND-Parameter von %s bei %L

en: Invalid SHIFT argument of DSHIFTL at %L
de: Ungültiges SHIFT-Argument von DSHIFTL bei %L

en: Invalid character in name at %C
de: Ungültiges Zeichen in Name bei %C

en: Invalid codimension %d at %C, only %d codimensions exist
de: Ungültige Codimension %d bei %C, nur %d Codimensionen existieren

en: Invalid context for NULL() pointer at %%L
de: Ungültiger Kontext für NULL()-Zeiger bei %%L

en: Invalid form of PROGRAM statement at %C
de: Ungültige Form der PROGRAM-Anweisung bei %C

en: Invalid form of array reference at %C
de: Ungültige Form der Feldreferenz bei %C

en: Invalid form of coarray reference at %C
de: Ungültige Form der Coarray-Referenz bei %C

en: Invalid image number %d in SYNC IMAGES
de: Ungültige Bildanzahl %d in SYNC IMAGES

en: Invalid initializer %s in Data statement at %C
de: Ungültige Initialisierung %s in Data-Anweisung bei %C

en: Invalid kind %d for CHARACTER constant at %C
de: Ungültige Art %d für CHARACTER-Konstante bei %C

en: Invalid kind for %s at %L
de: Ungültige Art für %s bei %L

en: Invalid real kind %d at %C
de: Unzulässige Realart %d bei %C

en: Invalid second argument of %s at %L
de: Ungültiges zweites Argument von %s bei %L

en: Invalid second argument of IBCLR at %L
de: Ungültiges zweites Argument von IBCLR bei %L

en: Invalid second argument of IBITS at %L
de: Ungültiges zweites Argument von IBITS bei %L

en: Invalid second argument of IBSET at %L
de: Ungültiges zweites Argument von IBSET bei %L

en: Invalid second argument of ISHFTC at %L
de: Ungültiges zweites Argument von ISHFTC bei %L

en: Invalid third argument of IBITS at %L
de: Ungültiges drittes Argument von IBITS bei %L

en: Invalid third argument of ISHFTC at %L
de: Ungültiges drittes Argument von ISHFTC bei %L

en: Issue warnings needed for strict compliance to the standard
de: Für strikte Standardbefolgung benötigte Warnungen ausgeben

en: Iterator step at %L cannot be zero
de: Iteratorschritt bei %L kann nicht Null sein

en: Java class %q#T object allocated using placement new
de: Objekt der Java-Klasse %q#T mit Platzierung new reserviert

en: Java class %qT cannot have a destructor
de: Java-Klasse %qT kann keinen Destruktor haben

en: Java class %qT cannot have an implicit non-trivial destructor
de: Java-Klasse %qT kann keinen impliziten nicht-trivialen Destruktor haben

en: Java class %qT cannot have multiple bases
de: Java-Klasse %qT kann nicht mehrere Basen haben

en: Java class %qT cannot have virtual bases
de: Java-Klasse %qT kann keine virtuellen Basen haben

en: Java method %qD has non-Java parameter type %qT
de: Java-Methode %qD hat Nicht-Java-Parametertyp %qT

en: Java method %qD has non-Java return type %qT
de: Java-Methode %qD hat Nicht-Java-Rückgabetyp %qT

en: Java object %qD not allocated with %<new%>
de: Java-Objekt %qD nicht mit %<new%> reserviert

en: Jump targets are aligned to this power of 2
de: Sprungziele werden zu dieser Zweierpotenz ausgerichtet

en: Junk after GENERIC binding at %C
de: Ausschuss hinter GENERIC-Bindung bei %C

en: Just generate unwind tables for exception handling
de: Einfach Abwicklungstabellen für Ausnahmebehandlung erzeugen

en: Just use icc0/fcc0
de: Einfach icc0/fcc0 verwenden

en: KIND parameter of %s at %L must be an initialization expression
de: KIND-Parameter von %s bei %L muss ein Initialisierungsausdruck sein

en: Keyword '%s' at %C has already appeared in the current argument list
de: Schlüsselwort »%s« bei %C bereits in aktueller Argumentliste aufgetreten

en: Keyword argument '%s' at %L is already associated with another actual argument
de: Schlüsselwort-Argument »%s« bei %L ist bereits mit einem anderen effektiven Argument verbunden

en: Keyword argument '%s' at %L is not in the procedure
de: Schlüsselwort-Argument »%s« bei %L ist nicht in der Prozedur

en: Kind %d is not supported for CHARACTER at %C
de: Die Art %d wird für CHARACTER bei %C nicht unterstützt

en: Kind %d not supported for type %s at %C
de: Die Art %d wird für Typ %s bei %C nicht unterstützt

en: L%d cache latency unknown for %s
de: L%d Cache-Wartezeit unbekannt für %s

en: LCFI labels have already been deferred
de:  LCFI-Marken wurden bereits zurückgestellt

en: LCFI labels have already been deferred.
de: LCFI-Marken wurden bereits zurückgestellt.

en: LHS in noreturn call
de: LHS in »noreturn«-Aufruf

en: LM label has already been deferred
de: LM-Marke wurde bereits zurückgestellt

en: LOGICAL operands are required in expression at %L
de: LOGICAL-Operanden werden in Ausdruck bei %L benötigt

en: LTO support has not been enabled in this configuration
de: LTO-Unterstützung wurde in dieser Konfiguration nicht aktiviert

en: Label %d at %C already referenced as a format label
de: Marke %d bei %C bereits als eine Formatmarke referenziert

en: Label %d at %C already referenced as branch target
de: Marke %d bei %C bereits als Sprungziel referenziert

en: Label %d at %C previously used as a FORMAT label
de: Marke %d bei %C vorher als FORMAT-Marke verwendet

en: Label %d at %C previously used as branch target
de: Marke %d bei %C vorher als Sprungziel verwendet

en: Label %d at %L defined but cannot be used
de: Marke %d bei %L definiert, kann aber nicht verwendet werden

en: Label %d at %L defined but not used
de: Marke %d bei %L definiert, aber nicht verwendet

en: Label %d referenced at %L is never defined
de: Marke %d wird bei %L referenziert aber nirgendwo definiert

en: Label '%s' at %C doesn't match IF label '%s'
de: Marke »%s« bei %C passt nicht zur IF-Marke »%s«

en: Label '%s' at %C doesn't match WHERE label '%s'
de: Marke »%s« bei %C passt nicht zur WHERE-Marke »%s«

en: Label at %L is not in the same block as the GOTO statement at %L
de: Marke bei %L ist nicht im gleichen Block wie GOTO-Anweisung bei %L

en: Label name '%s' at %C is ambiguous
de: Markenname »%s« bei %C ist mehrdeutig

en: Left parenthesis required after '*'
de: Linke Klammer benötigt nach »*«

en: Letter %c already has an IMPLICIT type at %C
de: Buchstabe %c hat bereits einen IMPLICIT-Typ bei %C

en: Letter '%c' already set in IMPLICIT statement at %C
de: Buchstabe »%c« bereits gesetzt in IMPLICIT-Anweisung bei %C

en: Letters must be in alphabetic order in IMPLICIT statement at %C
de: Buchstaben in IMPLICIT-Anweisung bei %C müssen in alphabetischer Reihenfolge sein

en: Lift restrictions on GOT size
de: Beschränkungen für GOT-Größe aufheben

en: Like -M but ignore system header files
de: Wie -M, aber System-Header-Dateien ignorieren

en: Like -MD but ignore system header files
de: Wie -MD, aber System-Header-Dateien ignorieren

en: Like -pedantic but issue them as errors
de: Wie -pedantic, aber als Fehler ausgeben

en: Limit of %d continuations exceeded in statement at %C
de: Grenze von %d Fortsetzungen in Anweisung bei %C überschritten

en: Line truncated at %L
de: Zeile bei %L wird abgeschnitten

en: Lines executed:%s of %d
de: %s von %d Zeilen ausgeführt

en: Link to emit program in ELF format (rather than mmo)
de: Binden, um Programm im ELF-Format auszugeben (statt mmo)

en: Link with libads.a, libc.a and crt0.o
de: Mit libads.a, libc.a und crt0.o binden

en: Link with libmvme.a, libc.a and crt0.o
de: Mit libmvme.a, libc.a und crt0.o binden

en: Link with libsim.a, libc.a and sim-crt0.o
de: Mit libsim.a, libc.a und sim-crt0.o binden

en: Link with libyk.a, libc.a and crt0.o
de: Mit libyk.a, libc.a und crt0.o binden

en: Link with the fast floating-point library
de: Mit schneller Gleitkomma-Bibliothek linken

en: Link with the library-pic libraries
de: Mit Library-PIC-Bibliotheken linken

en: Link-time optimization with number of parallel jobs or jobserver.
de: Optimierungen zur Linkzeit mit Anzahl paralleler Jobs oder Jobserver.

en: List all available debugging counters with their limits and counts.
de: Alle verfügbaren Fehleranalysezähler mit ihren Grenzen und Werten auflisten.

en: Logical SELECT CASE block at %L has more that two cases
de: Logischer SELECT CASE Block bei %L hat mehr als zwei Fälle

en: Logical range in CASE statement at %L is not allowed
de: Logischer Bereich in CASE-Anweisung bei %L ist nicht erlaubt

en: Logicals at %%L must be compared with %s instead of %s
de: Logische Werte bei %%L müssen mit %s statt mit %s verglichen werden

en: Look for and use PCH files even when preprocessing
de: PCH-Dateien suchen und verwenden, sogar bei Vorverarbeitung

en: Looks for opportunities to reduce stack adjustments and stack references.
de: Sucht Möglichkeiten, Stack-Anpassungen und Stack-Referenzen zu reduzieren.

en: Loop code aligned to this power of 2
de: Schleifen zu dieser Zweierpotenz ausrichten

en: Loop variable
de: Schleifenvariable

en: Loop variable at %C cannot be a sub-component
de: Schleifenvariable bei %C kann keine Unter-Komponente sein

en: Loop variable has been modified
de: Schleifenvariable wurde geändert

en: Loops iterating at least selected number of iterations will get loop alignement.
de: Schleifen mit mindestens der angegebenen Durchlaufzahl erhalten Schleifenausrichtung.

en: Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d
de: Untere Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d

en: Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d
de: Untere Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d

en: MCU %qs supported for assembler only
de: MCU %qs nur für Assemblierung unterstützt

en: MIPS16 -mxgot code
de: MIPS16 -mxgot Code

en: MIPS16 PIC for ABIs other than o32 and o64
de: MIPS16 PIC für ABIs außer o32 und o64

en: MIPS16 TLS
de: MIPS16-TLS

en: MMIX Internal: %s is not a shiftable int
de: MMIX-intern: %s ist kein schiebbares int

en: MMIX Internal: Bad register: %d
de: MMIX-intern: Falsches Register: %d

en: MMIX Internal: Bad value for 'm', not a CONST_INT
de: MMIX-intern: Falscher Wert für 'm', kein CONST_INT

en: MMIX Internal: Cannot decode this operand
de: MMIX-internal: Dieser Operand kann nicht dekodiert werden

en: MMIX Internal: Expected a CONST_INT, not this
de: MMIX-intern: CONST_INT erwartet, aber nicht dies

en: MMIX Internal: Expected a constant, not this
de: MMIX-intern: Konstante erwartet, aber nicht dies

en: MMIX Internal: Expected a register, not this
de: MMIX-intern: Register erwartet, aber nicht dies

en: MMIX Internal: Last named vararg would not fit in a register
de: MMIX-intern: Letzte benannte Vararg würde nicht in ein Register passen

en: MMIX Internal: Missing %qc case in mmix_print_operand
de: MMIX-intern: Fall %qc fehlt in mmix_print_operand

en: MMIX Internal: This is not a constant:
de: MMIX-intern: Dies ist keine Konstante:

en: MMIX Internal: This is not a recognized address
de: MMIX-intern: Diese Adresse wird nicht erkannt

en: MMIX Internal: Trying to output invalidly reversed condition:
de: MMIX-intern: Versuch, ungültig umgekehrte Bedingung auszugeben:

en: MMIX Internal: What is the CC of this?
de: MMIX-intern: Was ist der CC davon?

en: MMIX Internal: What's the CC of this?
de: MMIX-intern: Was ist der CC davon?

en: MMX vector argument without MMX enabled changes the ABI
de: MMX-Vektorargument ohne eingeschaltetes MMX ändert das ABI

en: MMX vector return without MMX enabled changes the ABI
de: MMX-Vektorrückgabe ohne eingeschaltetes MMX ändert das ABI

en: MODIFY_EXPR not expected while having tuples
de: MODIFY_EXPR nicht erwartet während es Tupel gibt

en: MODULE PROCEDURE at %C must be in a generic module interface
de: MODULE PROCEDURE bei %C muss in einer generischen Modulschnittstelle sein

en: MULT case in cris_op_str
de: MULT-Fall in cris_op_str

en: Magnitude of second argument of %s exceeds bit size at %L
de: Größe des zweiten Arguments von %s überschreitet Bit-Größe bei %L

en: Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %L
de: Größe des zweiten Arguments von ISHFTC überschreitet BIT_SIZE des ersten Arguments bei %L

en: Magnitude of second argument of ISHFTC exceeds third argument at %L
de: Größe des zweiten Arguments von ISHFTC überschreitet drittes Argument bei %L

en: Magnitude of third argument of ISHFTC exceeds BIT_SIZE of first argument at %L
de: Größe des dritten Arguments von ISHFTC überschreitet BIT_SIZE des ersten Arguments bei %L

en: Maintain backchain pointer
de: Rückwärtskettenzeiger pflegen

en: Make "char" signed by default
de: Macht »char« standardmäßig vorzeichenbehaftet

en: Make "char" unsigned by default
de: »char« standardmäßig vorzeichenlos machen

en: Make integers 32 bits wide
de: Ganzzahlen 32 Bit breit machen

en: Make structs a multiple of 4 bytes (warning: ABI altered)
de: Structs Vielfache von 4 Bytes machen (Warnung: ABI geändert)

en: Make sure loads and stores are not moved past DMA instructions
de: Sicherstellen, dass Laden/Speichern nicht hinter DMA-Befehle verschoben wird

en: Make the linker relaxation machine assume that a program counter wrap-around occurs.
de: Maschine zur Binder-Entspannung soll annehmen, dass ein Befehlszählerübersprung auftritt.

en: Malloc data into P2 space
de: Daten im P2-Raum reservieren

en: Map one directory name to another in debug information
de: In Fehlersuchinfo einen Verzeichnisnamen auf einen anderen abbilden

en: Mark MAC register as call-clobbered
de: MAC-Register als Aufruf-zerstört markieren

en: Mark __tls_get_addr calls with argument info
de: __tls_get_addr-Aufrufe mit Argumentinfo markieren

en: Mark all loops as parallel
de: Alle Schleifen als parallel markieren

en: Marks all inlined methods as having hidden visibility
de: Alle inline-Methoden mit versteckter Sichtbarkeit markieren

en: Max basic blocks number in loop for loop invariant motion
de: Höchstzahl der Basis-Blöcke in Schleife für Schleifeninvariantenbewegung

en: Max loops number for regional RA
de: Maximale Schleifenanzahl für regionales RA

en: Max size of conflict table in MB
de: Maximale Größe der Konflikttabelle in MB

en: Max. size of var tracking hash tables
de: Maximale Größe variablenverfolgender Hash-Tabellen

en: Maximal code growth caused by tail duplication (in percent)
de: Maximaler Code-Zuwachs durch Ende-Vervielfältigung (in Prozent)

en: Maximal growth due to inlining of large function (in percent)
de: Maximales Wachstum durch »inline« einer großen Funktion (in Prozent)

en: Maximal stack frame growth due to inlining (in percent)
de: Maximales Stack-Rahmen-Wachstum durch »inline« (in Prozent)

en: Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with
de: Maximales Größenwachstum neuer von ipa-sra durch Ersetzen von Zeigern auf Aggregate erzeugter Parameter

en: Maximum extension level reached with type '%s' at %L
de: Höchste Erweiterungsstufe mit Typ »%s« bei %L erreicht

en: Maximum length of partial antic set when performing tree pre optimization
de: Maximalgröße der partiellen Aufwandsmenge, wenn Baumvoroptimierung ausgeführt wird

en: Maximum number of fields in a structure before pointer analysis treats the structure as a single variable
de: Die Höchstzahl der Felder in einer Struktur, bevor Zeigeranalyse sie als einzelne Variable behandelt

en: Maximum number of instructions in basic block to be considered for SLP vectorization
de: Höchstzahl der in Basis-Block zu betrachtenden Anweisungen für SLP-Vektorisierung

en: Maximum number of instructions in the ready list that are considered eligible for renaming
de: Die Höchstzahl der Anweisungen in der fertigen Liste, die zur Umbenennung in Frage kommen

en: Maximum number of namespaces to search for alternatives when name lookup fails
de: Höchstzahl der nach Alternativen zu durchsuchenden Namensräume wenn Nachschlagen des Namens fehlschlägt

en: Maximum number of nops to insert for a hint (Default 2)
de: Höchstzahl der für einen Hinweis einzufügenden NOPs (Standard: 2)

en: Maximum number of statements allowed in a block that needs to be duplicated when threading jumps
de: Höchstzahl der in einem Block erlaubten Anweisungen, die für Sprungbehandlung vervielfältigt werden müssen

en: Maximum number of times that an insn could be scheduled
de: Höchstzahl, wie oft ein Befehl geplant werden könnte

en: Maximum size in bytes of constant values allowed as operands.
de: Maximalgröße der als Operanden erlaubten Konstantenwerte in Bytes.

en: Maximum size of a SCC before SCCVN stops processing a function
de: Maximalgröße eines SCC bevor SCCVN zur Bearbeitung einer Funktion anhält

en: Maximum size of a type list associated with each parameter for devirtualization
de: Maximale Größe einer für Devirtualisierung jedem Parameter zugeordneten Typenliste

en: Maximum size of global and static variables which can be placed into the small data area.
de: Maximalgröße der globalen und statischen Variable, die in kleine Datenbereiche gelegt werden.

en: Maximum subrecord length cannot exceed %d
de: Höchste Teildatensatzlänge kann %d nicht überschreiten

en: Maximum supported identifier length is %d
de: Höchste unterstützte Bezeichnerlänge ist %d

en: Memory allocation failed
de: Speicherreservierung gescheitert

en: Min. ratio of insns to mem ops to enable prefetching in a loop
de: Kleinstes Verhältnis von Befehlen zu Speicheroperationen, um Prefetching in einer Schleife zu aktivieren

en: Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count
de: Kleinstes Verhältnis von Befehlen zu Prefetches um Prefetching für eine Schleife mit unbekannter Frequentierung zu aktivieren

en: Min/max instructions allowed
de: Min/Max-Befehle erlaubt

en: Min/max instructions not allowed
de: Min/Max-Befehle nicht erlaubt

en: Minimal distance between possibly conflicting store and load
de: Kleinster Abstand zwischen möglicherweise in Konflikt stehendem Speichern und Laden

en: Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap
de: Minimale Heaperweiterung, die Speicherbereinigung anstößt, als Prozentsatz der Gesamtgröße des Heap

en: Minimum heap size before we start collecting garbage, in kilobytes
de: Kleinste Heapgröße vor Speicherbereinigungsbeginn, in Kilobytes

en: Minimum number of virtual mappings to consider switching to full virtual renames
de: Mindestanzahl der zum Umschalten auf vollständige virtuelle Umbenennungen zu betrachtenden virtuellen Mappings

en: Missing '&' in continued character constant at %C
de: In fortgesetzter Zeichenkonstante bei %C fehlt »&«

en: Missing SHAPE parameter for call to %s at %L
de: Fehlender SHAPE-Parameter für Aufruf von »%s« bei %L

en: Missing actual argument '%s' in call to '%s' at %L
de: Fehlendes effektives Argument »%s« in Aufruf von »%s« bei %L

en: Missing actual argument for argument '%s' at %L
de: Fehlendes effektives Argument für Argument »%s« bei %L

en: Missing alternate return spec in subroutine call at %L
de: Fehlende alternative Rückgabespezifikation in Unterprogrammaufruf bei %L

en: Missing argument list in function '%s' at %C
de: Fehlende Argumentliste in Funktion »%s« bei %C

en: Missing argument to '%s' at %C
de: Fehlendes Argument für »%s« bei %C

en: Missing array specification at %L in CODIMENSION statement
de: Feldspezifikation bei %L in CODIMENSION-Anweisung fehlt

en: Missing array specification at %L in DIMENSION statement
de: Fehlende Feldspezifikation bei %L in DIMENSION-Anweisung

en: Missing character range in IMPLICIT at %C
de: Fehlender Zeichenbereich in IMPLICIT bei %C

en: Missing closing paren for binding label at %C
de: Schließende Klammer für Bindungsmarke bei %C fehlt

en: Missing closing quote '"' for binding label at %C
de: Schließendes Anführungszeichen »"« für Bindungsmarke bei %C fehlt

en: Missing closing quote ''' for binding label at %C
de: Schließendes Anführungszeichen »'« für Bindungsmarke bei %C fehlt

en: Missing codimension specification at %C
de: Fehlende Kodimensionsangabe bei %C

en: Missing dimension specification at %C
de: Fehlende Dimensionsangabe bei %C

en: Missing entity or common block name for attribute specification statement at %C
de: Eintrag oder gemeinsamer Blockname für Attribut-Spezifikationsanweisung bei %C fehlt

en: Missing exponent in real number at %C
de: Fehlender Exponent in Realzahl bei %C

en: Missing format label at %C
de: Fehlende Format-Marke bei %C

en: Missing generic specification in USE statement at %C
de: Fehlende allgemeine Spezifikation in USE-Anweisung bei %C

en: Missing keyword name in actual argument list at %C
de: Fehlender Schlüsselwortname in effektiver Argumentliste bei %C

en: Missing kind-parameter at %C
de: Fehlender Art-Parameter bei %C

en: Missing leading left parenthesis
de: Führende linke Klammer fehlt

en: Missing required parentheses before BIND(C) at %C
de: Erforderte Klammern vor BIND(C) bei %C fehlen

en: Missing right parenthesis at %C
de: Fehlende rechte Klammer bei %C

en: Missing right parenthesis or comma at %C
de: Fehlende rechte Klammer oder Komma bei %C

en: Module %s at line %d column %d: %s
de: Modul %s in Zeile %d, Spalte %d: %s

en: Module nature in USE statement at %C shall be either INTRINSIC or NON_INTRINSIC
de: Modul-Eigenschaft in USE-Anweisung bei %C sollte entweder INTRINSIC oder NON_INTRINSIC sein

en: More actual than formal arguments in '%s' call at %L
de: Mehr effektive als formale Argumente in Aufruf von »%s« bei %L

en: More actual than formal arguments in procedure call at %L
de: Mehr effektive als formale Argumente in Prozeduraufruf bei %L

en: Move loop invariant computations out of loops
de: Berechnung der Schleifeninvarianten außerhalb der Schleifen legen

en: Multiple identifiers provided with single NAME= specifier at %C
de: Mehrere Bezeichner mit einzelner Spezifikation NAME= bei %C angegeben

en: NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C
de: NAME nicht erlaubt bei BIND(C) für ABSTRACT INTERFACE bei %C

en: NAMELIST object '%s' has PRIVATE components and cannot be a member of PUBLIC namelist '%s' at %L
de: NAMELIST-Objekt »%s« hat PRIVATE-Komponenten und kann kein Element der PUBLIC-Namensliste »%s« bei %L sein

en: NAMELIST object '%s' has use-associated PRIVATE components and cannot be member of namelist '%s' at %L
de: NAMELIST-Objekt »%s« hat benutzungs-verbundene PRIVATE-Komponenten und kann kein Element der Namensliste »%s« bei %L sein

en: NAMELIST object '%s' in namelist '%s' at %L has ALLOCATABLE or POINTER components and thus requires a defined input/output procedure
de: NAMELIST-Objekt »%s« in Namensliste »%s« bei %L hat ALLOCATABLE- oder POINTER-Komponenten und erfordert daher eine definierte Ein-/Ausgabeprozedur

en: NAMELIST object '%s' in namelist '%s' at %L is polymorphic and requires a defined input/output procedure
de: NAMELIST-Objekt »%s« in Namensliste »%s« bei %L ist polymorph und erfordert eine definierte Ein-/Ausgabeprozedur

en: NAMELIST object '%s' was declared PRIVATE and cannot be member of PUBLIC namelist '%s' at %L
de: NAMELIST-Objekt »%s« wurde als PRIVATE deklariert und kann kein Element der PUBLIC-Namensliste »%s« bei %L sein

en: NON_OVERRIDABLE and DEFERRED can't both appear at %C
de: NON_OVERRIDABLE und DEFERRED können nicht gleichzeitig bei %C auftreten

en: NOPASS or explicit interface required at %C
de: NOPASS oder explizite Schnittstelle bei %C erforderlich

en: NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d
de: NOTE_INSN_BASIC_BLOCK %d in der Mitte des Basis-Blocks %d

en: NOTE_INSN_BASIC_BLOCK is missing for block %d
de: NOTE_INSN_BASIC_BLOCK fehlt für Block %d

en: NULL appears on right-hand side in assignment at %L
de: Auf rechter Seite in Zuweisung bei %L tritt NULL auf

en: NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function
de: NULL-Zeiger bei %L ist nicht als effektives Argument der intrinsischen Funktion »%s« erlaubt

en: NULL used in arithmetic
de: NULL in Arithmetik verwendet

en: NULL() initialization at %C is ambiguous
de: NULL()-Initialisierung bei %C ist mehrdeutig

en: NUM_THREADS clause at %L requires a scalar INTEGER expression
de: Klausel NUM_THREADS bei %L erfordert einen skalaren INTEGER-Ausdruck

en: Name '%s' at %C is already defined as a generic interface at %L
de: Name »%s« bei %C ist bereits als eine allgemeine Schnittstelle bei %L definiert

en: Name '%s' at %C is an ambiguous reference to '%s' from current program unit
de: Name »%s« bei %C ist eine mehrdeutige Referenz auf »%s« von aktueller Programmeinheit

en: Name '%s' at %C is an ambiguous reference to '%s' from module '%s'
de: Name »%s« bei %C ist eine mehrdeutige Referenz auf »%s« vom Modul »%s«

en: Name '%s' at %C is the name of the procedure
de: Name »%s« bei %C ist der Name der Prozedur

en: Name '%s' of ABSTRACT INTERFACE at %C cannot be the same as an intrinsic type
de: Name »%s« des ABSTRACT INTERFACE bei %C kann nicht der gleiche wie ein intrinsischer Typ sein

en: Name after !$omp critical and !$omp end critical does not match at %C
de: Name hinter »!$omp critical« und »!$omp end critical« passt nicht bei %C

en: Name at %C is too long
de: Name bei %C ist zu lang

en: Name too long
de: Name zu lang

en: Named COMMON block '%s' at %L shall be of the same size
de: Benannter COMMON-Block »%s« bei %L sollte die gleiche Größe haben

en: Named constant '%s' at %L cannot be an EQUIVALENCE object
de: Benannte Konstante »%s« bei %L kann kein EQUIVALENCE-Objekt sein

en: Named constant at %C in an EQUIVALENCE
de: Benannte Konstante bei %C in EQUIVALENCE

en: Namelist %s cannot be renamed by USE association to %s
de: Namensliste %s kann nicht mit USE-Verbindung in %s umbenannt werden

en: Namelist group name '%s' at %C already has a basic type of %s
de: Gruppenname »%s« der Namensliste bei %C hat bereits einen Basistypen von »%s«

en: Namelist group name '%s' at %C already is USE associated and cannot be respecified.
de: Gruppenname »%s« der Namensliste bei %C ist bereits USE-verbunden und kann nicht respezifiziert werden.

en: Need either entity or common block name for attribute specification statement at %C
de: Entweder Eintrag oder gemeinsamer Blockname für Attribut-Spezifikationsanweisung bei %C erforderlich

en: No binding name is allowed in BIND(C) at %C
de: In BIND(C) bei %C ist kein bindender Name erlaubt

en: No branches
de: Keine Zweige

en: No calls
de: Keine Aufrufe

en: No default crt0.o
de: Kein voreingestelltes crt0.o

en: No executable lines
de: Keine ausführbaren Zeilen

en: No longer supported
de: Wird nicht mehr unterstützt

en: No such symbol in TYPE definition at %C
de: Kein solches Symbol in TYPE-Definition bei %C

en: Non-ELEMENTAL user-defined assignment in WHERE at %L
de: Benutzerdefinierte Nicht-ELEMENTAL-Zuweisung in WHERE bei %L

en: Non-PARAMETER symbol '%s' at %L can't be implied-shape
de: Nicht-PARAMETER-Symbol »%s« bei %L kann nicht implizite Form haben

en: Non-THREADPRIVATE object '%s' in COPYIN clause at %L
de: Nicht-threadprivates Objekt »%s« in Klausel COPYIN bei %L

en: Non-constant lower bound in implied-shape declaration at %L
de: Nicht-konstante untere Grenze in Deklaration mit impliziter Form bei %L

en: Non-numeric character in statement label at %C
de: Nicht-numerisches Zeichen in Anweisungsmarke bei %C

en: Nonconforming tab character at %C
de: Tab-Zeichen bei %C passt nicht

en: Nonconforming tab character in column %d of line %d
de: Unpassendes Tab-Zeichen in Spalte %d der Zeile %d

en: Nonconstant array section at %L in DATA statement
de: Abschnitt eines nicht konstanten Feldes bei %L in DATA-Anweisung

en: Nonnegative width required
de: Nicht-negative Breite benötigt

en: Nonstandard type declaration %s*%d at %C
de: Nicht-Standard Typ-Deklaration %s*%d bei %C

en: Not a valid Java .class file.
de: Keine gültige Java-.class-Datei.

en: Not yet implemented: IMAGE_INDEX for coarray with non-constant cobounds at %L
de: Noch nicht implementiert: IMAGE_INDEX für Coarray mit nicht konstanten Co-Grenzen bei %L

en: Not yet implemented: LCOBOUND for coarray with non-constant cobounds at %L
de: Noch nicht implementiert: LCOBOUND für Coarray mit nicht konstanten Co-Grenzen bei %L

en: Not yet implemented: THIS_IMAGE for coarray with non-constant cobounds at %L
de: Noch nicht implementiert: THIS_IMAGE für Coarray mit nicht konstanten Co-Grenzen bei %L

en: Not yet implemented: UCOBOUND for coarray with non-constant cobounds at %L
de: Noch nicht implementiert: UCOBOUND für Coarray mit nicht konstanten Co-Grenzen bei %L

en: Number of paritions program should be split to
de: Anzahl der Partitionen, in die das Programm aufgeteilt werden soll

en: Number of registers used to pass integer arguments
de: Anzahl der zur Übergabe von Ganzzahlargumenten verwendeten Register

en: Numeric PARAMETER required in complex constant at %C
de: Numerischer PARAMETER in komplexer Konstante bei %C erforderlich

en: Numeric operands are required in expression at %L
de: In Ausdruck bei %L werden numerische Operanden benötigt

en: Numeric or CHARACTER operands are required in expression at %L
de: Numerische oder CHARACTER-Operanden benötigt in Ausdruck bei %L

en: OPEN statement not allowed in PURE procedure at %C
de: OPEN-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: OPTIONAL is not allowed inside of BLOCK at %C
de: OPTIONAL ist in BLOCK bei %C nicht erlaubt

en: Objective-C declarations may only appear in global scope
de: Objective-C-Deklarationen dürfen nur im globalen Gültigkeitsbereich erscheinen

en: Obsolescent feature: Old-style character length at %C
de: Veraltete Funktion: Zeichenlänge alten Stils bei %C

en: Old-style type declaration %s*%d not supported at %C
de: Deklaration %s*%d im alten Stil wird bei %C nicht unterstützt

en: Omit frame pointer for leaf functions
de: Rahmenzeiger für Blattfunktionen auslassen

en: Omit range reduction step when performing complex division
de: Schritt zur Bereichsverkleinerung auslassen, wenn komplexe Division durchgeführt wird

en: Omit the frame pointer in leaf functions
de: Rahmenzeiger in Blattfunktionen auslassen

en: Only generate absolute relocations on word sized values.
de: Absolute Auslagerungen nur bei Werten mit Wordgrößen erzeugen.

en: Only intrinsic operators can be used in expression at %L
de: Nur intrinsische Operatoren können in Ausdruck bei %L verwendet werden

en: Only issue one instruction per cycle
de: Nur einen Befehl pro Durchgang ausgeben

en: Only use 32 FPRs
de: Nur 32 FPRs verwenden

en: Only use 32 GPRs
de: Nur 32 GPR verwenden

en: OpenMP directives at %C may not appear in PURE or ELEMENTAL procedures
de: OpenMP-Anweisungen bei %C dürfen in PURE- oder ELEMENTAL-Prozeduren nicht auftreten

en: Operand of .not. operator at %%L is %s
de: Operand des Operators .not. bei %%L ist %s

en: Operand of unary numeric operator '%s' at %%L is %s
de: Operand des unären numerischen Operators »%s« bei %%L ist %s

en: Operand of user operator '%s' at %%L is %s
de: Operand des Benutzeroperators »%s« bei %%L ist %s

en: Operands of binary numeric operator '%s' at %%L are %s/%s
de: Operanden des binären numerischen Operators »%s« bei %%L sind %s/%s

en: Operands of comparison operator '%s' at %%L are %s/%s
de: Operanden des Vergleichsoperators »%s« bei %%L sind %s/%s

en: Operands of logical operator '%s' at %%L are %s/%s
de: Operanden des logischen Operators »%s« bei %%L sind %s/%s

en: Operands of string concatenation operator at %%L are %s/%s
de: Operanden des Zeichenkettenverkettungsoperators bei %%L sind %s/%s

en: Operands of user operator '%s' at %%L are %s/%s
de: Operanden des Benutzeroperators »%s« bei %%L sind %s/%s

en: Operator interface at %L conflicts with intrinsic interface
de: Operatorschnittstelle bei %L steht mit intrinsischer Schnittstelle in Konflikt

en: Operator interface at %L has the wrong number of arguments
de: Operatorschnittstelle bei %L hat falsche Argumentanzahl

en: Operator interface at %L must have, at most, two arguments
de: Operatorschnittstelle bei %L darf höchstens zwei Argumente haben

en: Optimize for space rather than speed
de: Auf Größe statt Geschwindigkeit optimieren

en: Optimize for speed disregarding exact standards compliance
de: Optimiert auf Geschwindigkeit unter Missachtung genauer Standardkonformität

en: Optimize induction variables on trees
de: Induktionsvariablen auf Bäumen optimieren

en: Optimize lui/addiu address loads
de: lui/addiu-Adressladebefehle optimieren

en: Optimize sibling and tail recursive calls
de: Geschwister- und endrekursive Aufrufe optimieren

en: Optimize tail call instructions in assembler and linker
de: Ende-Aufruf-Befehle in Assembler und Binder optimieren

en: Option tag unknown
de: Optionsmarke unbekannt

en: Options:
de: Optionen:

en: Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)
de: Außerhalb des Wertebereichs in IMAGE_INDEX bei %L für Dimension %d, SUB hat %ld und untere Grenze für COARRAY ist %ld

en: Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)
de: Außerhalb des Wertebereichs in IMAGE_INDEX bei %L für Dimension %d, SUB hat %ld und obere Grenze für COARRAY ist %ld

en: Out of stack space.
de: Stapelspeicher aufgebraucht.

en: Output a class file
de: Klassendatei ausgeben

en: Output stack usage information on a per-function basis
de: Information über Stapelbenutzung auf Funktionsbasis ausgeben

en: Overlapping unequal initializers in EQUIVALENCE at %L
de: Überlappende ungleiche Initialisierungen in EQUIVALENCE bei %L

en: Override -mbest-lib-options
de: -mbest-lib-options überschreiben

en: P descriptor requires leading scale factor
de: P-Deskriptor benötigt führenden Skalierungsfaktor

en: PARAMETER '%s' is used at %L before its definition is complete
de: PARAMETER »%s« wird bei %L verwendet, bevor dessen Definition vollständig ist

en: PARAMETER at %L is missing an initializer
de: fehlende Initialisierung für PARAMETER bei %L

en: PCS variant
de: PCS-Variante

en: PHI argument is missing for edge %d->%d
de: PHI-Argument fehlt für Kante %d->%d

en: PHI argument is not SSA_NAME, or invariant
de: PHI-Argument ist kein SSA_NAME, oder invariant

en: PHI argument is not a GIMPLE value
de: PHI-Argument ist kein GIMPLE-Wert

en: PIC code generation is not compatible with fast indirect calls
de: PIC-Codeerzeugung ist mit schnellen indirekten Aufrufen unverträglich

en: PIC code generation is not supported in the portable runtime model
de: PIC-Codeerzeugung wird im portierbaren Laufzeitmodell nicht unterstützt

en: PIC is only supported for RTPs
de: PIC wird nur für RTPs unterstützt

en: PIC is required but not supported with CONST16 instructions
de: PIC wird benötigt, wird aber nicht mit CONST16-Befehlen unterstützt

en: PIC register clobbered by %qs in %<asm%>
de: PIC-Register durch %qs in %<asm%> zerstört

en: PIC register isn't set up
de: PIC-Register ist nicht vorbereitet

en: POINTER attribute is required for procedure pointer component at %C
de: POINTER-Attribut ist für Prozedurzeiger-Komponente bei %C erforderlich

en: POINTER object '%s' in %s clause at %L
de: POINTER-Objekt »%s« in Klausel %s bei %L

en: POINTER valued function appears on right-hand side of assignment at %L
de: POINTER-wertige Funktion tritt auf rechter Seite der Zuweisung bei %L auf

en: PRE disabled
de: PRE ausgeschaltet

en: PRINT namelist at %C is an extension
de: PRINT-Namensliste bei %C ist eine Erweiterung

en: PRINT statement at %C not allowed within PURE procedure
de: PRINT-Anweisung bei %C innerhalb PURE-Prozedur nicht erlaubt

en: PRINT_OPERAND null pointer
de: PRINT_OPERAND Null-Zeiger

en: PRINT_OPERAND, invalid insn for %%C
de: PRINT_OPERAND, ungültiger Befehl für %%C

en: PRINT_OPERAND, invalid insn for %%N
de: PRINT_OPERAND, ungültiger Befehl für %%N

en: PRINT_OPERAND: Unknown punctuation '%c'
de: PRINT_OPERAND: Unbekanntes Zeichen '%c'

en: PRINT_OPERAND_ADDRESS, null pointer
de: PRINT_OPERAND_ADDRESS, Null-Zeiger

en: PRIVATE statement at %C is only allowed in the specification part of a module
de: PRIVATE-Anweisung bei %C ist nur in Spezifikationsteil eines Moduls erlaubt

en: PRIVATE statement at %C must precede structure components
de: PRIVATE-Anweisung bei %C muss Strukturkomponenten vorausgehen

en: PRIVATE statement in TYPE at %C must be inside a MODULE
de: PRIVATE-Anweisung in TYPE bei %C muss innerhalb eines MODULEs sein

en: PROCEDURE at %C must be in a generic interface
de: PROCEDURE bei %C muss in einer allgemeinen Schnittstelle sein

en: PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L
de: Attribut PROCEDURE steht mit Attribut NAMELIST in »%s« bei %L in Konflikt

en: PROCEDURE attribute conflicts with PROTECTED attribute at %L
de: Attribut PROCEDURE steht mit Attribut PROTECTED bei %L in Konflikt

en: PROCEDURE(interface) at %C should be declared DEFERRED
de: PROCEDURE(Schnittstelle) bei %C sollte als DEFERRED deklariert sein

en: PROTECTED at %C only allowed in specification part of a module
de: PROTECTED bei %C nur in Spezifikationsabschnitts eines Moduls erlaubt

en: PROTECTED attribute conflicts with EXTERNAL attribute at %L
de: Attribut PROTECTED steht mit Attribut EXTERNAL bei %L in Konflikt

en: PUBLIC statement at %C is only allowed in the specification part of a module
de: PUBLIC-Anweisung bei %C ist nur in Spezifikationsteil eines Moduls erlaubt

en: PURE and IMPURE must not appear both at %C
de: PURE und IMPURE dürfen bei %C nicht gleichzeitig stehen

en: PUT uses port array index %d, which is out of range [%d..%d)
de: PUT verwendet Port-Feldindex %d, was außerhalb des Wertebereiches [%d..%d) liegt

en: Pack VLIW instructions
de: VLIW-Befehle packen

en: Pack structure members together without holes
de: Strukturelemente ohne Lücken zusammenpacken

en: Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression
de: Parameter »%s« bei %L wurde nicht deklariert oder ist eine Variable, die nicht zu konstantem Ausdruck reduziert

en: Parameter '%s' to '%s' at %L must be BIND(C)
de: Parameter »%s« für »%s« bei %L muss BIND(C) sein

en: Parameter '%s' to '%s' at %L must be a procedure
de: Parameter »%s« für »%s« bei %L muss eine Prozedur sein

en: Parameter '%s' to '%s' at %L must be a scalar
de: Parameter »%s« für »%s« bei %L muss ein Skalar sein

en: Parameter '%s' to '%s' at %L must be either a TARGET or an associated pointer
de: Parameter »%s« für »%s« bei %L muss entweder ein TARGET oder ein zugeordneter Zeiger sein

en: Parameter array '%s' at %L cannot be automatic or of deferred shape
de: Parameterfeld »%s« bei %L kann nicht automatische oder vermutete Form haben

en: Pass -z text to linker
de: -z text an den Linker übergeben

en: Pass FP arguments in FP registers
de: FP-Argumente an FP-Register übergeben

en: Pass the address of the ra save location to _mcount in $12
de: Adresse der RA-Speicherstelle an _mcount in $12 übergeben

en: Passing internal procedure at %L by location not allowed
de: Übergabe der eingebauten Prozedur über die Speicherstelle ist bei %L nicht erlaubt

en: Pay attention to the "inline" keyword
de: Auf das »inline«-Schlüsselwort achten

en: Perform DWARF2 duplicate elimination
de: DWARF2-Wiederholungsbeseitigung durchführen

en: Perform Interprocedural constant propagation
de: Zwischenprozedurale Konstantenweitergabe durchführen

en: Perform SMS based modulo scheduling before the first scheduling pass
de: SMS-basierte modulo-Planung vor erstem Planungsdurchlauf durchführen

en: Perform SMS based modulo scheduling with register moves allowed
de: SMS-basierte modulo-Planung mit erlaubten Register-Bewegungen durchführen

en: Perform VR4130-specific alignment optimizations
de: VR4130-spezifische Ausrichtungs-Optimierungen durchführen

en: Perform Value Range Propagation on trees
de: Wertebereichsweitergabe auf Bäumen durchführen

en: Perform a forward propagation pass on RTL
de: Schritt zur Vorwärts-Übertragung auf RTL durchführen

en: Perform a number of minor, expensive optimizations
de: Eine Reihe kleiner, aber teurer, Optimierungen durchführen

en: Perform a register copy-propagation optimization pass
de: Optimierungsdurchlauf zur Kopierübertragung von Registern durchführen

en: Perform a register renaming optimization pass
de: Einen Optimierungsdurchgang zur Registerumbenennung durchführen

en: Perform branch target load optimization after prologue / epilogue threading
de: Ladeoptimierung für Sprungziele nach Prolog/Epilog-Behandlung ausführen

en: Perform branch target load optimization before prologue / epilogue threading
de: Ladeoptimierungen für Sprungziele vor Prolog/Epilog-Behandlung ausführen

en: Perform cloning to make Interprocedural constant propagation stronger
de: Kopien erzeugen, um zwischenprozedurale Konstantenweitergabe zu verstärken

en: Perform comparison elimination after register allocation has finished
de: Beseitigung von Vergleichen nach Registerreservierung durchführen

en: Perform conversion of conditional jumps to branchless equivalents
de: Umwandlung bedingter Sprünge in zweiglose Äquivalente durchführen

en: Perform conversion of conditional jumps to conditional execution
de: Umwandlung bedingter Sprünge in bedingte Ausführung durchführen

en: Perform conversions of switch initializations.
de: Umwandlungen von »switch«-Initialisierungen durchführen.

en: Perform cross-jumping optimization
de: Optimierung zum Kreuzsprung durchführen

en: Perform early inlining
de: Frühes Inlining durchführen

en: Perform enhanced load motion during global common subexpression elimination
de: Erweiterte Ladebewegung während Beseitigung globaler gemeinsamer Teilausdrücke durchführen

en: Perform function-local points-to analysis on trees.
de: Funktionslokale Analyse von Zeigerzielen auf Bäumen durchführen.

en: Perform global common subexpression elimination
de: Beseitigung globaler gemeinsamer Teilausdrücke durchführen

en: Perform global common subexpression elimination after register allocation
de: Beseitigung globaler gemeinsamer Teilausdrücke nach Registerreservierung durchführen

en: Perform indirect inlining
de: Indirektes Inlining durchführen

en: Perform interprocedural points-to analysis
de: Zwischenprozedurale Zeigeranalyse durchführen

en: Perform interprocedural profile propagation
de: Zwischenprozedurale Profilweitergabe durchführen

en: Perform interprocedural reduction of aggregates
de: Zwischenprozedurale Reduktion von Aggregaten durchführen

en: Perform jump threading optimizations
de: Sprung-Threading-Optimierungen durchführen

en: Perform live range splitting during the SSA->normal pass
de: Lebensdaueraufteilung während des SSA-Normaldurchlaufs durchführen

en: Perform loop peeling
de: Schleifen-Schälung durchführen

en: Perform loop unrolling for all loops
de: Schleifenabwicklung für alle Schleifen durchführen

en: Perform loop unrolling when iteration count is known
de: Schleifenabwicklung durchführen, wenn Anzahl der Wiederholungen bekannt ist

en: Perform loop unswitching
de: Schleifenausschaltung durchführen

en: Perform matrix layout flattening and transposing based
de: Matrixanordnung aufgrund Abflachung und Transponierung durchführen

en: Perform partial inlining
de: Teilweises Inlining durchführen

en: Perform redundant load after store elimination in global common subexpression
de: Beseitigung überflüssigen Ladens nach dem Abspeichern in globalem gemeinsamem Teilausdruck durchführen

en: Perform scalar replacement of aggregates
de: Skalarersetzung von Aggregaten durchführen

en: Perform store motion after global common subexpression elimination
de: Speicherbewegung nach Beseitigung globaler gemeinsamer Teilausdrücke durchführen

en: Perform structure layout optimizations based
de: Optimierungsgestützte Strukturanordnung durchführen

en: Perform superblock formation via tail duplication
de: Superblockerzeugung über Ende-Vervielfältigung durchführen

en: Perform unused type elimination in debug info
de: Beseitigung ungenutzter Typen in Info zur Fehlersuche durchführen

en: Perform variable tracking
de: Variablenverfolgung durchführen

en: Perform variable tracking and also tag variables that are uninitialized
de: Variablenverfolgung durchführen und auch Variablen markieren, die uninitialisiert sind

en: Perform variable tracking by annotating assignments
de: Variablenverfolgung durch Zuweisungsanmerkungen durchführen

en: Perform whole program optimizations
de: Gesamtprogrammoptimierung durchführen

en: Period required in format specifier
de: Punkt in Formatspezifikation erforderlich

en: Permit '$' as an identifier character
de: »$« als Bezeichnerzeichen zulassen

en: Permit nonconforming uses of the tab character
de: Unpassende Verwendungen des TAB-Zeichens erlauben

en: Permit scheduling of a function's prologue sequence
de: Planung einer Funktionsprologsequenz erlauben

en: Permit the use of the assert keyword
de: Die Verwendung des Schlüsselworts »assert« erlauben

en: Permit universal character names (\u and \U) in identifiers
de: Universelle Zeichennamen (\u und \U) in Bezeichnern zulassen

en: Place a stop bit after every cycle when scheduling
de: Bei Planung ein Stop-Bit nach jedem Takt einfügen

en: Place data items into their own section
de: Datenstücke in ihren eigenen Abschnitt legen

en: Place each function into its own section
de: Jede Funktion in ihren eigenen Abschnitt platzieren

en: Place floating point constants in TOC
de: Gleitkommakonstanten ins TOC legen

en: Place symbol+offset constants in TOC
de: Symbol+Offset-Konstanten ins TOC legen

en: Please submit a full bug report,
    with preprocessed source if appropriate.
    See %s for instructions.
de: Bitte senden Sie einen vollständigen Fehlerbericht auf Englisch ein;
    bearbeiten Sie die Quellen zunächst mit einem Präprozessor, wenn es
    dienlich ist.
    Fehler in der deutschen Übersetzung sind an translation-team-de@lists.sourceforge.net zu melden.
    
    Gehen Sie gemäß den Hinweisen in %s vor.

en: Pointer array component of structure at %C must have a deferred shape
de: Zeigerfeld-Komponente der Struktur bei %C muss eine aufgeschobene Form haben

en: Pointer assignment target is neither TARGET nor POINTER at %L
de: Zeiger-Zuweisungsziel bei %L ist weder TARGET noch POINTER

en: Pointer assignment target is not a POINTER at %L
de: Zeiger-Zuweisungziel ist kein POINTER bei %L

en: Pointer assignment with vector subscript on rhs at %L
de: Zeigerzuweisung mit Vektorindex für rhs bei %L

en: Pointer initialization at %C requires '=>', not '='
de: Zeigerinitialisierung bei %C benötigt »=>«, nicht »=«

en: Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument '%s' due to VOLATILE attribute
de: Zeigerfeld als effektives Argument bei %L erfordert wegen VOLATILE-Attribut ein Scheinargument »%s« mit vermuteter Form oder als Zeigerfeld

en: Pointers are 32-bit
de: Zeiger sind 32 Bit

en: Pointers are 64-bit
de: Zeiger sind 64 Bit

en: Polymorphic array at %C not yet supported
de: Polymorphes Feld bei %C wird noch nicht unterstützt

en: Positive exponent width required
de: Positive Exponentenbreite erforderlich

en: Positive width required
de: Positive Breite benötigt

en: Positive width required with T descriptor
de: Mit T-Deskriptor positive Breite benötigt

en: Prefer branches over conditional execution
de: Zweige gegenüber bedingter Ausführung bevorzugen

en: Prefer word accesses over byte accesses
de: Wortzugriffe bevorzugen (statt Bytezugriffen)

en: Prepend global symbols with ":" (for use with PREFIX)
de: Globalen Symbolen ein »:« voranstellen (für Verwendung mit PREFIX)

en: Prepend the name of the cpu to all public symbol names
de: Namen der CPU allen öffentlichen Symbolnamen voranstellen

en: Preprocess directives only.
de: Nur Direktiven vorverarbeiten.

en: Pretend a branch-around-a-move is a conditional move.
de: Vorgeben, dass Sprung-um-Sprung ein bedingter Sprung ist

en: Pretend that branches are expensive
de: Vorgeben, dass Sprünge teuer sind

en: Prevent the use of all floating-point operations
de: Verwendung aller Gleitkommaoperationen verhindern

en: Prevent the use of all hardware floating-point instructions
de: Verwendung aller Hardware-Gleitkommabefehle verhindern

en: Print code coverage information.
de: Information zur Code-Überdeckung ausgeben.

en: Print extra (possibly unwanted) warnings
de: Zusätzliche (möglicherweise ungewollte) Warnungen ausgeben

en: Print the name of header files as they are used
de: Namen der Header-Dateien ausgeben, wie sie verwendet werden

en: Probability that COMDAT function will be shared with different compilatoin unit
de: Wahrscheinlichkeit, dass COMDAT-Funktion mit anderer Kompilationseinheit geteilt wird

en: Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L
de: Prozedur »%s« bei %C hat eine explizite Schnittstelle und darf bei %L keine Attribute deklariert haben

en: Procedure '%s' at %C is already defined at %L
de: Prozedur »%s« bei %C wurde bereits bei %L definiert

en: Procedure '%s' at %L already has basic type of %s
de: Prozedur »%s« bei %L hat bereits grundlegenden Typen %s

en: Procedure '%s' at %L may not have basic type of %s
de: Prozedur »%s« bei %L kann nicht grundlegenden Typen %s haben

en: Procedure '%s' at %L must have the BIND(C) attribute to be C interoperable
de: Prozedur »%s« bei %L muss das BIND(C)-Attribut haben, um mit C interoperabel zu sein

en: Procedure '%s' called with an implicit interface at %L
de: Prozedur »%s« mit einer impliziten Schnittstelle bei %L aufgerufen

en: Procedure '%s' in %s at %L has no explicit interface
de: Prozedur »%s« in %s bei %L hat keine explizite Schnittstelle

en: Procedure '%s' in %s at %L is neither function nor subroutine
de: Prozedur »%s« in %s bei %L ist weder Funktion noch Subroutine

en: Procedure argument at %L is INTENT(IN) while interface specifies INTENT(%s)
de: Prozedurargument bei %L ist INTENT(IN) während die Schnittstelle INTENT(%s) angibt

en: Procedure argument at %L is local to a PURE procedure and has the POINTER attribute
de: Prozedurargument bei %L ist lokal für PURE-Prozedur und hat das POINTER-Attribut

en: Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument
de: Prozedurargument bei %L ist lokal für PURE-Prozedur und wird an Argument INTENT(%s) übergeben

en: Process #ident directives
de: #ident-Anweisungen verarbeiten

en: Processing spec %c%s%c, which is '%s'
de: Spezifikation %c%s%c wird verarbeitet, welche »%s« ist

en: Produce a backtrace when a runtime error is encountered
de: Backtrace erzeugen, wenn Laufzeitfehler auftritt

en: Produce a warning at runtime if a array temporary has been created for a procedure argument
de: Warnung zur Laufzeit erzeugen, wenn ein temporäres Feld für Prozedurargument erzeugt wurde

en: Produce big endian code
de: Big-Endian-Code erzeugen

en: Produce code relocatable at runtime
de: Zur Laufzeit verschiebbaren Code erzeugen

en: Produce little endian code
de: Little-Endian-Code erzeugen

en: Program is entirely located in low 64k of memory
de: Programm befindet sich vollständig in unteren 64k des Speichers

en: Prohibit PC relative function calls
de: PC-relative Funktionsaufrufe verbieten

en: Protect parentheses in expressions
de: Klammern in Ausdrücken schützen

en: Provide libraries for the simulator
de: Bibliotheken für den Simulator anbieten

en: Put everything in the regular TOC
de: Alles in reguläres TOC legen

en: Put jump tables for switch statements into the .data section rather than the .code section
de: Sprungtabellen für »switch«-Anweisungen in den .data-Abschnitt statt in den .code-Abschnitt einfügen

en: Put jumps in call delay slots
de: Sprünge in Aufrufverzögerungsschlitze stecken

en: Put uninitialized constants in ROM (needs -membedded-data)
de: Uninitialisierte Konstanten im ROM ablegen (benötigt -membedded-data)

en: Put zero initialized data in the bss section
de: Null-initialisierte Daten in den bss-Abschnitt legen

en: RESULT variable at %C must be different than function name
de: RESULT-Variable bei %C muss vom Funktionsnamen verschieden sein

en: RESULT_DECL should be read only when DECL_BY_REFERENCE is set
de: RESULT_DECL sollte nur gelesen werden, wenn DECL_BY_REFERENCE gesetzt ist

en: RETURN_ADDRESS_OFFSET not supported
de: RETURN_ADDRESS_OFFSET nicht unterstützt

en: RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d
de: RTL-Überprüfung: Zugriff von Elt %d von »%s« mit letztem Elt %d in %s, bei %s:%d

en: RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d
de: RTL-Überprüfung: Zugriff von Elt %d von Vektor mit letztem Elt %d in %s, bei %s:%d

en: RTL check: attempt to treat non-block symbol as a block symbol in %s, at %s:%d
de: RTL-Überprüfung: Versuch, Nicht-Blocksymbol als Blocksymbol in %s bei %s:%d zu verwenden

en: RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d
de: RTL-Überprüfung: Code »%s« oder »%s« erwartet, haben »%s« in %s, bei %s:%d

en: RTL check: expected code '%s', have '%s' in %s, at %s:%d
de: RTL-Überprüfung: Code »%s« erwartet, haben »%s« in %s, bei %s:%d

en: RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d
de: RTL-Überprüfung: Elt-%d-Typ %c oder %c erwartet, haben Typ %c (rtx %s) in %s, bei %s:%d

en: RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d
de: RTL-Überprüfung: Elt-%d-Typ %c erwartet, haben Typ %c (rtx %s) in %s, bei %s:%d

en: RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d
de: RTL-Kennzeichenüberprüfung: %s mit unerwartetem RTX-Code »%s« in %s bei %s:%d verwendet

en: RTP PIC is incompatible with -msingle-pic-base
de: RTP PIC ist mit -msingle-pic-base unverträglich

en: RTP PIC is incompatible with Thumb
de: RTP PIC ist mit Thumb unverträglich

en: RX FPU instructions do not support NaNs and infinities
de: RX-FPU-Befehle unterstützen keine NaNs und Unendlichkeiten

en: Raising a negative REAL at %L to a REAL power is prohibited
de: Erhöhung eines negativen REAL bei %L zu einer REAL-Potenz ist verboten

en: Range specification at %L can never be matched
de: Bereichsspezifikation bei %L kann nie passen

en: Rank mismatch in array reference at %L (%d/%d)
de: Unpassende Ränge in Feldreferenz bei %L (%d/%d)

en: Ratio between virtual mappings and virtual symbols to do full virtual renames
de: Verhältnis zwischen virtuellen Mappings und virtuellen Symbolen für vollständige virtuelle Umbenennungen

en: Reading file '%s' as free form
de: Datei »%s« wird in Freiform gelesen

en: Reading module %s at line %d column %d: %s
de: Modul %s in Zeile %d, Spalte %d wird gelesen: %s

en: Reading specs from %s
de: Lesen der Spezifikationen von %s

en: Real constant overflows its kind at %C
de: Realkonstante überschreitet seine Art bei %C

en: Real constant underflows its kind at %C
de: Realkonstante unterschreitet seine Art bei %C

en: Real number at %C has a 'd' exponent and an explicit kind
de: Realzahl bei %C hat »d«-Exponent und explizite Art

en: Real number at %C has a 'q' exponent and an explicit kind
de: Realzahl bei %C hat einen »q«-Exponenten und eine explizite Art

en: Realign stack in prologue
de: Stack in Prolog neu ausrichten

en: Reallocate the LHS in assignments
de: LHS in Zuweisungen neu reservieren

en: Recognize C++ keywords like "compl" and "xor"
de: C++-Schlüsselworte wie »compl« und »xor« erkennen

en: Recognize GNU-defined keywords
de: GNU-definierte Schlüsselworte erkennen

en: Recognize built-in functions
de: Eingebaute Funktionen erkennen

en: Recognize the "asm" keyword
de: Das »asm«-Schlüsselwort erkennen

en: Record gcc command line switches in the object file.
de: GCC-Kommandozeilenschalter in Objektdateien aufzeichnen.

en: Reduce the amount of reflection meta-data generated
de: Betrag der generierten Metadaten zur Reflexion verringern

en: Reduce the size of object files
de: Größe von Objektdateien reduzieren

en: Relax branches
de: Zweige entspannen

en: Remap file names when including files
de: Dateinamen beim Einfügen von Dateien neu abbilden

en: Remove redundant membars
de: Redundante Membars entfernen

en: Reorder basic blocks and partition into hot and cold sections
de: Basisblöcke und Partition in heiße und kalte Abschnitte umordnen

en: Reorder basic blocks to improve code placement
de: Basisblöcke umsortieren, um Codeplatzierung zu verbessern

en: Reorder functions to improve code placement
de: Funktionen umsortieren, um Codeplatzierung zu verbessern

en: Reorder top level functions, variables, and asms
de: Funktionen, Variablen und asms höchster Ebene umordnen

en: Replace SSA temporaries with better names in copies
de: Vorübergehende SSA-Speicherbereiche in Kopien mit besseren Namen ersetzen

en: Replace add, compare, branch with branch on count register
de: Addieren, Vergleichen, Verzweigen mit Verzweigung anhand des Zählregisters ersetzen

en: Replace temporary expressions in the SSA->normal pass
de: Vorübergehende Ausdrücke im SSA-Normaldurchlauf ersetzen

en: Report on memory allocation before interprocedural optimization
de: Über Speicherbelegung vor zwischenprozeduraler Optimierung berichten

en: Report on permanent memory allocation
de: Über dauerhafte Speicherreservierung berichten

en: Report the time taken by each compiler pass
de: Benötigte Zeit für jeden Compilerdurchlauf ausgeben

en: Report various link-time optimization statistics
de: Verschiedene Statistiken über Linkzeit-Optimierung ausgeben

en: Request IEEE-conformant math library routines (OSF/1)
de: IEEE-konforme Mathematik-Bibliotheksroutinen (OSF/1) anfordern

en: Reschedule instructions after register allocation
de: Befehle nach Registerbelegung neu planen

en: Reschedule instructions before register allocation
de: Befehle vor Registerbelegung neu planen

en: Reserve space for outgoing arguments in the function prologue
de: Platz für Ausgabeargumente in Funktionsprolog reservieren

en: Restrict doloop to the given nesting level
de: doloop auf angegebene Verschachtelungstiefe beschränken

en: Restrict target load migration not to re-use registers in any basic block
de: In Basis-Blöcken keine Register bei der Ziel-Lade-Bewegung wiederverwenden

en: Restrict the use of hardware floating-point instructions to 32-bit operations
de: Verwendung der Hardware-Gleitkomma-Befehle auf 32-Bit-Operationen beschränken

en: Result '%s' of contained function '%s' at %L has no IMPLICIT type
de: Ergebnis »%s« der enthaltenen Funktion »%s« bei %L hat keinen IMPLICIT-Typ«

en: Result of %s gives range error for its kind at %L
de: Ergebnis von %s ergibt für seine Art einen Bereichsfehler bei %L

en: Result of %s is NaN at %L
de: Ergebnis von %s ist NaN bei %L

en: Result of %s overflows its kind at %L
de: Ergebnis von %s überschreitet seine Art bei %L

en: Result of %s underflows its kind at %L
de: Ergebnis von %s unterschreitet seine Art bei %L

en: Result of BESSEL_YN is -INF at %L
de: Ergebnis von BESSEL_YN ist -INF bei %L

en: Result of NEAREST is NaN at %L
de: Ergebnis von NEAREST ist NaN bei %L

en: Result of SCALE overflows its kind at %L
de: Ergebnis von SCALE überschreitet seine Art bei %L

en: Return 8-byte vectors in memory
de: 8-Byte-Vektoren über Speicher zurückgeben

en: Return all structures in memory (AIX default)
de: Alle Strukturen über Speicher zurückgeben (AIX-Standard)

en: Return floating-point results in ac0 (fr0 in Unix assembler syntax)
de: Gleitkommaergebnisse über ac0 zurückgeben (fr0 in Unix-Assemblersyntax)

en: Return pointers in both a0 and d0
de: Zeiger sowohl in a0 als auch in d0 zurück geben

en: Return small aggregates in memory, not registers
de: Kleine Aggregate über Speicher, nicht Register, zurückgeben

en: Return small aggregates in registers
de: Kleine Aggregate über Register zurückgeben

en: Return small structures in registers (SVR4 default)
de: Kleine Strukturen über Register zurückgeben (SVR4-Standard)

en: Return type of BIND(C) function '%s' at %L cannot be a character string
de: Rückgabetyp der BIND(C)-Funktion »%s« bei %L kann keine Zeichenkette sein

en: Return type of BIND(C) function '%s' at %L cannot be an array
de: Rückgabetyp der BIND(C)-Funktion »%s« bei %L kann kein Feld sein

en: Return values of functions in FPU registers
de: Funktionswerte über FPU-Register zurück geben

en: Reuse r30 on a per function basis
de: r30 auf Funktionsbasis wiederverwenden

en: Rightmost upper bound of assumed size array section not specified at %L
de: Rechte obere Schranke des Feldabschnitts angenommener Größe nicht angegeben bei %L

en: Run only the second compilation of -fcompare-debug
de: Nur die zweite Kompilierung von -fcompare-debug laufen lassen

en: Run predictive commoning optimization.
de: Vorhersehende vereinheitlichende Optimierung durchlaufen.

en: Run selective scheduling after reload
de: Ausgewählte Planung nach Neuladen laufen lassen

en: Run the link-time optimizer in local transformation (LTRANS) mode.
de: Den Bindezeitoptimierer im lokalen Transformationsmodus (LTRANS) laufen lassen.

en: Run the link-time optimizer in whole program analysis (WPA) mode.
de: Den Bindezeitoptimierer im Modus »komplettes Programm« (WPA) laufen lassen.

en: Runtime name.
de: Laufzeitname.

en: SAVE attribute at %L cannot be specified in a PURE procedure
de: SAVE-Attribut bei %L kann nicht in einer PURE-Prozedur angegeben werden

en: SAVE statement at %C follows blanket SAVE statement
de: SAVE-Anweisung bei %C folgt umfassender SAVE-Anweisung

en: SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression
de: chunk_size der Klausel SCHEDULE bei %L erfordert einen skalaren INTEGER-Ausdruck

en: SEQUENCE attribute at %C already specified in TYPE statement
de: SEQUENCE-Attribut bei %C bereits in TYPE-Anweisung angegeben

en: SEQUENCE statement at %C must precede structure components
de: SEQUENCE-Anweisung bei %C muss Strukturkomponenten vorausgehen

en: SH2a does not support little-endian
de: SH2a unterstützt nicht Little-Endian

en: SHAPE parameter for call to %s at %L must be a rank 1 INTEGER array
de: SHAPE-Parameter für Aufruf von %s bei %L muss ein INTEGER-Feld mit Rang 1 sein

en: SPE not supported in this target
de: SPE wird für dieses Ziel nicht unterstützt

en: SSA corruption
de: SSA-Beschädigung

en: SSA name in freelist but still referenced
de: SSA-Name in Frei-Liste, jedoch immer noch referenziert

en: SSA_NAME created in two different blocks %i and %i
de: SSA_NAME in zwei verschiedenen Blöcken (%i und %i) erzeugt

en: SSA_NAME_DEF_STMT is wrong
de: SSA_NAME_DEF_STMT ist falsch

en: SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set
de: SSA_NAME_OCCURS_IN_ABNORMAL_PHI sollte gesetzt sein

en: SSE instruction set disabled, using 387 arithmetics
de: SSE-Befehlssatz ausgeschaltet, es wird 387-Arithmetik verwendet

en: SSE register argument with SSE disabled
de: SSE-Registerargument mit SSE ausgeschaltet

en: SSE register return with SSE disabled
de: SSE-Registerrückgabe mit SSE ausgeschaltet

en: SSE vector argument without SSE enabled changes the ABI
de: SSE-Vektorargument ohne eingeschaltetes SSE ändert das ABI

en: SSE vector return without SSE enabled changes the ABI
de: SSE-Vektorrückgabe ohne eingeschaltetes SSE ändert das ABI

en: STAT variable
de: STAT-Variable

en: Same actual argument associated with INTENT(%s) argument '%s' and INTENT(%s) argument '%s' at %L
de: Gleiches effektives Argument mit INTENT(%s)-Argument »%s« und INTENT(%s)-Argument »%s« bei %L verbunden

en: Same as -fassociative-math for expressions which include division.
de: Das gleiche wie -fassociative-math für Ausdrücke, die Division enthalten.

en: Same as: -mep -mprolog-function
de: Das gleiche wie: -mep -mprolog-function

en: Save registers around function calls
de: Register bei Funktionsaufrufen sichern

en: Scalar '%s' in FORMAT tag at %L is not an ASSIGNED variable
de: Skalares »%s« in FORMAT-Marke bei %L ist keine ASSIGNED-Variable

en: Scalar PARAMETER required in complex constant at %C
de: Skalarer PARAMETER in komplexer Konstante bei %C erwartet

en: Scalar object '%s' at %L may not be ALLOCATABLE
de: Skalares Objekt »%s« bei %L kann nicht ALLOCATABLE sein

en: Schedule code for given CPU
de: Code für die gegebene CPU planen

en: Schedule given CPU
de: Für angegebene CPU planen

en: Schedule the start and end of the procedure
de: Anfang und Ende der Prozedur planen

en: Scope of for-init-statement variables is local to the loop
de: Sichtbarkeitsbereich der Variablen aus einer for-Initialisierungs-Anweisung ist für die Schleife lokal

en: Second argument MOD at %L is zero
de: Zweites Argument von MOD bei %L ist Null

en: Second argument of %s is negative at %L
de: Zweites Argument von %s ist bei %L negativ

en: Second argument of IBCLR exceeds bit size at %L
de: Zweites Argument von IBCLR überschreitet Bit-Größe bei %L

en: Second argument of IBSET exceeds bit size at %L
de: Zweites Argument von IBSET überschreitet Bit-Größe bei %L

en: Second argument of MOD at %L is zero
de: Zweites Argument von MOD bei %L ist Null

en: Second argument of MODULO at %L is zero
de: Zweites Argument von MODULO bei %L ist Null

en: Second argument of NEAREST at %L shall not be zero
de: Zweites Argument von NEAREST bei %L sollte nicht Null sein

en: Second argument of defined assignment at %L must be INTENT(IN)
de: Zweites Argument der definierten Zuweisung bei %L muss INTENT(IN)

en: Second argument of operator interface at %L cannot be optional
de: Zweites Argument der Operatorschnittstelle bei %L kann nicht optional sein

en: Second argument of operator interface at %L must be INTENT(IN)
de: Zweites Argument der Operatorschnittstelle bei %L muss INTENT(IN) sein

en: Section to put all const variables in (tiny, near, far) (no default)
de: Sektion für alle konstanten Variablen (tiny, near, far) (kein Standard)

en: Segmentation Fault
de: Speicherzugriffsverletzung

en: Segmentation Fault (code)
de: Speicherzugriffsverletzung (Code)

en: Select ABI calling convention
de: ABI-Aufrufkonvention auswählen

en: Select code model
de: Codemodell auswählen

en: Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot
de: Auswahl des Anteils an der Anzahl der Wiederholungen des Basisblocks im Programm, vorausgesetzt, der Basisblock muss als »heiß« angesehen werden

en: Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment
de: Auswahl des Anteils an der Höchstfrequenz der Ausführungen des Basisblocks in Funktion, vorausgesetzt, der Basisblock wird ausgerichtet

en: Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot
de: Auswahl des Anteils an der Höchstfrequenz der Ausführungen des Basisblocks in Funktion, vorausgesetzt, der Basisblock muss als »heiß« angesehen werden

en: Select method for sdata handling
de: Methode für sdata-Behandlung auswählen

en: Selection expression in computed GOTO statement at %L must be a scalar integer expression
de: Auswahlausdruck in berechneter GOTO-Anweisung bei %L muss ein skalarer Ganzzahlausdruck sein

en: Semicolon at %C needs to be preceded by statement
de: Semikolon bei %C muss Anweisung vorausgehen

en: Set 80387 floating-point precision (-mpc32, -mpc64, -mpc80)
de: Gleitkommapräzision von 80387 setzen (-mpc32, -mpc64, -mpc80)

en: Set Windows defines
de: Windows-defines setzen

en: Set default accessibility of module entities to PRIVATE.
de: Standardzugriff von Modulentitäten auf PRIVATE setzen.

en: Set dependence distance checking in premature scheduling of queued insns
de: Prüfung der Abhängigkeitsentfernung in nicht ausgereifter Planung von eingereihten Befehlen setzen

en: Set errno after built-in math functions
de: Nach eingebauten Mathematikfunktionen errno setzen

en: Set name of main routine for the debugger
de: Name der Hauptroutine für den Debugger setzen

en: Set sizeof(bool) to 1
de: sizeof(bool) auf 1 setzen

en: Set start-address of data
de: Start-Adresse der Daten setzen

en: Set start-address of the program
de: Start-Adresse des Programmes setzen

en: Set the PPC_EMB bit in the ELF flags header
de: PPC_EMB-Bit im ELF-Flags-Header setzen

en: Set the cost of branches
de: Sprungkosten setzen

en: Set the default double precision kind to an 8 byte wide type
de: Standard-Doppelpräzisionsart auf einen 8 Bytes breiten Typen setzen

en: Set the default integer kind to an 8 byte wide type
de: Standard-Ganzahlart auf einen 8 Bytes breiten Typen setzen

en: Set the default real kind to an 8 byte wide type
de: Standard-Realzahlart auf einen 8 Bytes breiten Typen setzen

en: Set the max size of data eligible for the SDA area
de: Maximalgröße der für den SDA-Bereich geeigneten Daten setzen

en: Set the max size of data eligible for the TDA area
de: Maximalgröße der für den TDA-Bereich geeigneten Daten setzen

en: Set the max size of data eligible for the ZDA area
de: Maximalgröße der für den ZDA-Bereich geeigneten Daten setzen

en: Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered
de: Höchstanzahl der Bytes angeben, die noch im Stack übrig sind, bevor ein Trap-Befehl ausgelöst wird

en: Set the maximum amount for a single stack increment operation
de: Größten Betrag für einzelne Stapelvergrößerungsoperation setzen

en: Set the source language version
de: Version der Quellsprache setzen

en: Set the target CPU type
de: Ziel-CPU-Typ angeben

en: Set the target VM version
de: Ziel-VM-Version angeben

en: Setting spec %s to '%s'
de: Spezifikation %s wird auf '%s' gesetzt

en: Shapes for operands at %L and %L are not conformable
de: Formen der Operanden bei %L und %L stimmen nicht überein

en: Share slots for saving different hard registers.
de: Schlitze gemeinsam verwenden, um verschiedene harte Register zu sichern.

en: Share stack slots for spilled pseudo-registers.
de: Stack-Schlitze für übergelaufene Pseudo-Register gemeinsam verwenden.

en: Shorten address references during linking
de: Beim Binden Adressreferenzen verkürzen

en: Show column numbers in diagnostics, when available.  Default on
de: Spaltenzahlen in Diagnose zeigen, wenn verfügbar. Standard: Ein

en: Single-precision floating point unit
de: Gleitkommaeinheit mit einfacher Genauigkeit

en: Size (in KB) of software data cache
de: Größe (in KB) des Software-Datencache

en: Size of '%s' argument of '%s' intrinsic at %L too small (%i/%i)
de: Größe des Arguments »%s« des intrinsischen »%s« bei %L ist zu klein (%i/%i)

en: Size of minimal paritition for WHOPR (in estimated instructions)
de: Größe der minimalen Partition für WHOPR (in voraussichtlichen Befehlen)

en: Small data area: none, sdata, use
de: Kleiner Datenbereich: keiner, sdata, verwenden

en: Specification function '%s' at %L cannot be RECURSIVE
de: Spezifikationsfunktion »%s« bei %L kann nicht RECURSIVE sein

en: Specification function '%s' at %L cannot be a statement function
de: Spezifikationsfunktion »%s« bei %L kann keine Anweisungsfunktion sein

en: Specification function '%s' at %L cannot be an internal function
de: Spezifikationsfunktion »%s« bei %L kann keine interne Funktion sein

en: Specification function '%s' at %L must be PURE
de: Spezifikationsfunktion »%s« bei %L muss PURE sein

en: Specifies the number of registers to reserve for interrupt handlers.
de: Anzahl der für Interrupthandler zu reservierenden Register.

en: Specifies whether interrupt functions should save and restore the accumulator register.
de: Angabe, ob Interruptfunktionen das Akkumulator-Register sichern und wiederherstellen sollen.

en: Specify CPU for code generation purposes
de: CPU für Codeerzeugungszwecke angeben

en: Specify CPU for scheduling purposes
de: CPU für Planzwecke angeben

en: Specify CPU for scheduling purposes.  Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000
de: CPU für Planzwecke angeben. Gültige Argumente sind 700, 7100, 7100LC, 7200, 7300, und 8000

en: Specify UNIX standard for predefines and linking
de: UNIX-Standard für Predefines und Bindung angeben

en: Specify Xilinx FPU.
de: Xilinx-FPU angeben

en: Specify a file to which a list of files output by LTRANS is written.
de: Gibt die Datei an, welche die Liste der von LTRANS ausgegebenen Dateien geschrieben wird.

en: Specify a plugin to load
de: Zu ladendes Plugin angeben

en: Specify alignment of structure fields default/natural
de: Ausrichtung der Strukturfelder als Standard/natürlich angeben

en: Specify an ABI
de: ABI angeben

en: Specify bit size of immediate TLS offsets
de: Bit-Breite des unmittelbaren TLS-Versatzes angeben

en: Specify cache flush function
de: Funktion zum Entleeren des Cache angeben

en: Specify cache flush trap number
de: Abfangfunktionsnummer zum Entleeren des Cache angeben

en: Specify cost of branches (Default 20)
de: Sprungkosten angeben (Standard: 20)

en: Specify how many bytes should be moved inline before calling out to memcpy/memmove
de: Angabe, wie viele Bytes inline bewegt werden, bevor memcpy/memmove aufgerufen wird

en: Specify how to access the thread pointer
de: Angeben, wie auf Threadzeiger zugegriffen wird

en: Specify if floating point hardware should be used
de: Angeben, ob Gleitkommahardware verwendet werden sollte

en: Specify main object for TPF-OS
de: Hauptobjekt für TPF-OS angeben

en: Specify name for 32 bit signed division function
de: Namen für vorzeichenbehaftete 32-Bit Divisionsfunktion angeben

en: Specify range of registers to make fixed
de: Bereich der zu fixierenden Register angeben

en: Specify scheduling priority for dispatch slot restricted insns
de: Planungspriorität für Verteilschlitz-beschränkte Befehle angeben

en: Specify that an external BLAS library should be used for matmul calls on large-size arrays
de: Angeben, dass eine externe BLAS-Bibliothek für matmul-Aufrufe mit großen Feldern verwendet werden sollte

en: Specify that backslash in string introduces an escape character
de: Angeben, dass Bachslashes in Zeichenketten ein Fluchtzeichen einführen

en: Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements
de: Angeben, dass keine implizite Typisierung erlaubt ist, außer es wird durch explizite IMPLICIT-Anweisungen überschrieben

en: Specify the __fp16 floating-point format
de: Gleitkommaformat __fp16 angeben

en: Specify the minimum bit alignment of structures
de: Kleinste Bitausrichtung von Strukturen angeben

en: Specify the name of the target CPU
de: Namen der Ziel-CPU angeben

en: Specify the name of the target architecture
de: Namen der Ziel-Architektur angeben

en: Specify the name of the target floating point hardware/format
de: Namen der Gleitkommahardware/-format des Zielsystems angeben

en: Specify the register allocation order
de: Reihenfolge der Registerbelegung angeben

en: Specify the register to be used for PIC addressing
de: Für PIC-Adressierung zu verwendendes Register angeben

en: Specify the target CPU
de: Die Ziel-CPU auswählen

en: Specify the target RX cpu type.
de: Typ der Ziel-RX-CPU auswählen.

en: Specify where to find the compiled intrinsic modules
de: Angeben, wo die kompilierten intrinsischen Module zu finden sind

en: Specify whether the byte access instructions should be used. Enabled by default.
de: Verwendung der Byte-Zugriffsbefehle (Standard).

en: Specify which post scheduling nop insertion scheme to apply
de: Angeben, welches Schema zum Einfügen von nops nach der Planung angewendet werden soll

en: Specify which type of AE to target. This option sets the mul-type and byte-access.
de: Der abzuzielende AE-Typ. Diese Option setzt den MUL-Typ und Byte-Zugriff.

en: Specify which type of multiplication to use. Can be mem, mac or none.
de: Typ der zu verwendenden Multiplikation. mem, mac oder none.

en: Specifying VOLATILE for coarray variable '%s' at %C, which is use-/host-associated
de: VOLATILE für Coarray-Variable »%s« bei »%C« angegeben, die use-/host-assoziiert ist

en: Split lifetimes of induction variables when loops are unrolled
de: Lebensdauer von Induktionsvariablen aufteilen, wenn Schleifen abgerollt werden

en: Split wide types into independent registers
de: Breite Typen in unabhängige Register aufteilen

en: Start expression in DO loop
de: Anfangs-Ausdruck in DO-Schleife

en: Statement at %L is not a valid branch target statement for the branch statement at %L
de: Anweisung bei %L ist keine gültige Sprungzielanweisung für Sprungziel bei %L

en: Statement function '%s' at %L is not allowed as an actual argument
de: Anweisungsfunktion »%s« bei %L ist nicht als effektives Argument erlaubt

en: Statement function '%s' requires argument list at %C
de: Anweisungsfunktion »%s« erfordert Argumentliste bei %C

en: Statement function at %L is recursive
de: Anweisungsfunktion bei %L ist rekursiv

en: Statement label at %C is zero
de: Anweisungsmarke bei %C ist Null

en: Statement label in ENDDO at %C doesn't match DO label
de: Anweisungsmarke in ENDDO bei %C passt nicht zum DO-Label

en: Statement label list in GOTO at %C cannot be empty
de: Anweisungsmarkenliste in GOTO bei %C kann nicht leer sein

en: Statically link the GNU Fortran helper library (libgfortran)
de: GNU Fortran Hilfsbibliothek (libgfortran) statisch binden

en: Step expression in DO loop
de: Schrittausdruck in DO-Schleife

en: Step expression in DO loop at %L cannot be zero
de: Schrittausdruck in DO-Schleife bei %L kann nicht Null sein

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available
de: Vorwärtswachstum anhalten, wenn die Wahrscheinlichkeit der besten Kante weniger als dieser Schwellwert ist. Verwendet, wenn Profil-Rückmeldung verfügbar ist

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available
de: Vorwärtswachstum anhalten, wenn die Wahrscheinlichkeit der besten Kante weniger als dieser Schwellwert ist. Verwendet, wenn Profil-Rückmeldung nicht verfügbar ist

en: Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)
de: Umgekehrtes Wachstum anhalten, wenn die umgekehrte Wahrscheinlichkeit der besten Kante weniger als dieser Schwellwert ist (in Prozent)

en: Store doubles in 64 bits.
de: Doubles in 64 Bits speichern.

en: Store function names in object code
de: Funktionsnamen im Objektcode speichern

en: Stores doubles in 32 bits.  This is the default.
de: Doubles in 32 Bits speichern. Dies ist Standard.

en: Strides not allowed in coarray subscript at %C
de: Schrittweiten in Coarray-Index bei %C nicht erlaubt

en: Structure component '%s' at %L cannot be an EQUIVALENCE object
de: Strukturkomponente »%s« bei %L kann kein EQUIVALENCE-Objekt sein

en: Subroutine '%s' at %L is INTRINSIC but is not compatible with an intrinsic
de: Unterprogramm »%s« bei %L ist INTRINSIC aber nicht mit eingebauter Funktion verträglich

en: Subroutine call to '%s' at %L is not PURE
de: Unterprogrammaufruf von »%s« bei %L ist nicht PURE

en: Subroutine call to '%s' in FORALL block at %L is not PURE
de: Unterprogrammaufruf von »%s« in FORALL-Block bei %L ist nicht PURE

en: Subroutine call to intrinsic '%s' at %L is not PURE
de: Unterprogrammaufruf des intrinsischen »%s« bei %L ist nicht PURE

en: Substring at %L has length zero
de: Teilzeichenkette bei %L hat Länge Null

en: Substring end index at %L exceeds the string length
de: End-Index der Teilzeichenkette bei %L überschreitet Zeichenkettenlänge

en: Substring end index at %L must be of type INTEGER
de: End-Index der Teilzeichenkette bei %L muss INTEGER-Typ haben

en: Substring end index at %L must be scalar
de: End-Index der Teilzeichenkette bei %L muss skalar sein

en: Substring start index at %L is less than one
de: Anfangs-Index der Teilzeichenkette bei %L ist kleiner als Eins

en: Substring start index at %L must be of type INTEGER
de: Anfangs-Index der Teilzeichenkette bei %L muss INTEGER-Typ haben

en: Substring start index at %L must be scalar
de: Anfangs-Index der Teilzeichenkette bei %L muss skalar sein

en: Sum of second and third arguments of IBITS exceeds bit size at %L
de: Summe des zweiten und dritten Arguments von IBITS überschreitet Bit-Größe bei %L

en: Support 3DNow! built-in functions
de: Eingebaute 3DNow!-Funktionen unterstützen

en: Support AES built-in functions and code generation
de: Eingebaute AES-Funktionen und Codeerzeugung unterstützen

en: Support Athlon 3Dnow! built-in functions
de: Eingebaute Athlon 3Dnow!-Funktionen unterstützen

en: Support BMI built-in functions and code generation
de: Eingebaute BMI-Funktionen und Codeerzeugung unterstützen

en: Support F16C built-in functions and code generation
de: Eingebaute F16C-Funktionen und Codeerzeugung unterstützen

en: Support FMA4 built-in functions and code generation
de: Eingebaute FMA4-Funktionen und Codeerzeugung unterstützen

en: Support FSGSBASE built-in functions and code generation
de: Eingebaute FSGSBASE-Funktionen und Codeerzeugung unterstützen

en: Support Green Hills ABI
de: Green Hills ABI unterstützen

en: Support LWP built-in functions and code generation
de: Eingebaute LWP-Funktionen und Codeerzeugung unterstützen

en: Support MMX and SSE built-in functions and code generation
de: Eingebaute MMX- und SSE-Funktionen und Codeerzeugung unterstützen

en: Support MMX built-in functions
de: Eingebaute MMX-Funktionen unterstützen

en: Support MMX, SSE and SSE2 built-in functions and code generation
de: Eingebaute MMX-, SSE- und SSE2-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2- und SSE3-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2-, SSE3- und SSE4A-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2-, SSE3- und SSSE3-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2-, SSE3-, SSSE3- und SSE4.1-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1- und SSE4.2-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2- und AVX-Funktionen und Codeerzeugung unterstützen

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation
de: Eingebaute MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX- und FMA-Funktionen und Codeerzeugung unterstützen

en: Support PCLMUL built-in functions and code generation
de: Eingebaute PCLMUL-Funktionen und Codeerzeugung unterstützen

en: Support RDRND built-in functions and code generation
de: Eingebaute RDRND-Funktionen und Codeerzeugung unterstützen

en: Support SCORE 7 ISA
de: SCORE 7 ISA unuterstützen

en: Support SCORE 7D ISA
de: SCORE 7D ISA unterstützen

en: Support TBM built-in functions and code generation
de: Eingebaute TBM-Funktionen und Codeerzeugung unterstützen

en: Support TLS segment larger than 64K
de: TLS-Segment >64K unterstützen

en: Support XOP built-in functions and code generation
de: Eingebaute XOP-Funktionen und Codeerzeugung unterstützen

en: Support calls between Thumb and ARM instruction sets
de: Aufrufe zwischen Thumb- und ARM-Befehlssätzen unterstützen

en: Support code generation of Advanced Bit Manipulation (ABM) instructions.
de: Codeerzeugung der Advanced Bit Manipulation Befehle (ABM) unterstützen.

en: Support code generation of cmpxchg16b instruction.
de: Codeerzeugung von cmpxchg16b-Befehlen unterstützen.

en: Support code generation of crc32 instruction.
de: Codeerzeugung von crc32-Befehlen unterstützen.

en: Support code generation of movbe instruction.
de: Codeerzeugung von movbe-Befehlen unterstützen.

en: Support code generation of popcnt instruction.
de: Codeerzeugung von popcnt-Befehlen unterstützen.

en: Support code generation of sahf instruction in 64bit x86-64 code.
de: Codeerzeugung von sahf-Befehlen in 64-Bit x86-64-Code unterstützen.

en: Support legacy multi-threading
de: Altes Multi-Threading unterstützen

en: Support message passing with the Parallel Environment
de: Message Passing mit paralleler Umgebung unterstützen

en: Support more than 8192 GOT entries on ColdFire
de: Mehr als 8192 GOT-Einträge auf ColdFire erzeugen

en: Support multi-threading
de: Multi-Threading unterstützen

en: Support multiply accumulate instructions
de: Mehrere Akkumulierbefehle unterstützen

en: Support synchronous non-call exceptions
de: Synchrone Nicht-Aufruf-Ausnahmen unterstützen

en: Suppress output of addresses in debugging dumps
de: Ausgabe von Adressen in Fehlersuch-Auszügen unterdrücken

en: Suppress output of instruction numbers, line number notes and addresses in debugging dumps
de: Ausgabe von Befehlszahlen, Zeilennummernangaben und Adressen in Fehlersuch-Auszügen unterdrücken

en: Suppress output of previous and next insn numbers in debugging dumps
de: Ausgabe der vorigen und nächsten Befehlszahlen in Fehlersuch-Auszügen unterdrücken

en: Suppress warnings
de: Warnungen unterdrücken

en: Swap endianness for unformatted files
de: Bytereihenfolge für unformatierte Dateien wechseln

en: Switch on/off MIPS16 ASE on alternating functions for compiler testing
de: MIPS16 ASE bei abwechselnden Funktionen für Compilertest ein-/ausschalten

en: Symbol '%s' already declared
de: Symbol »%s« bereits deklariert

en: Symbol '%s' at %C has already been host associated
de: Symbol »%s« bei %C wurde bereits mit Host verbunden

en: Symbol '%s' at %C is already an external symbol that is not COMMON
de: Symbol »%s« bei %C ist bereits ein externes Symbol, das nicht COMMON ist

en: Symbol '%s' at %C is already in a COMMON block
de: Symbol »%s« bei %C ist bereits in einem COMMON-Block

en: Symbol '%s' at %C is ambiguous
de: Symbol»%s« bei %C ist mehrdeutig

en: Symbol '%s' at %C must be a NAMELIST group name
de: Symbol »%s« bei %C muss ein NAMELIST-Gruppenname sein

en: Symbol '%s' at %L already has an explicit interface
de: Symbol »%s« bei %L hat bereits eine explizite Schnittstelle

en: Symbol '%s' at %L already has basic type of %s
de: Symbol »%s« bei %L hat bereits grundlegenden Typen %s

en: Symbol '%s' at %L cannot have a type
de: Symbol »%s« bei %L kann keinen Typen haben

en: Symbol '%s' at %L has no IMPLICIT type
de: Symbol »%s« bei %L hat keinen IMPLICIT-Typ

en: Symbol '%s' at %L is ambiguous
de: Symbol »%s« bei %L ist mehrdeutig

en: Symbol '%s' at %L is marked PRIVATE but has been given the binding label '%s'
de: Symbol »%s« bei %L ist als PRIVATE markiert, aber wurde mit Bindung »%s« markiert

en: Symbol '%s' in COMMON at %C cannot be a POINTER array
de: Symbol »%s« in COMMON bei %C kann kein POINTER-Feld sein

en: Symbol '%s' in namelist '%s' is INTENT(IN) at %C
de: Symbol »%s« in Namensliste »%s« ist INTENT(IN) bei %C

en: Symbol '%s' must be a PARAMETER in DATA statement at %C
de: Symbol »%s« muss ein PARAMETER in DATA-Anweisung bei %C sein

en: Symbol '%s' present on multiple clauses at %L
de: Symbol »%s« bei %L in mehreren Klauseln vorhanden

en: Symbol '%s' referenced at %L not found in intrinsic module ISO_C_BINDING
de: Bei %2$L referenziertes Symbol »%1$s« nicht im Modul ISO_C_BINDING gefunden

en: Symbol '%s' referenced at %L not found in intrinsic module ISO_FORTRAN_ENV
de: Bei %2$L referenziertes Symbol »%1$s« nicht im intrinsischen Modul ISO_FORTRAN_ENV gefunden

en: Symbol '%s' referenced at %L not found in module '%s'
de: Bei %2$L referenziertes Symbol »%1$s« nicht im Modul »%3$s« gefunden

en: Symbol '%s', in COMMON block '%s' at %C is being indirectly equivalenced to another COMMON block '%s'
de: Symbol »%s« in COMMON-Block »%s« bei %C ist indirekt äquivalent zu anderem COMMON-Block »%s«

en: Symbol at %C is not appropriate for an expression
de: Symbol bei %C passt nicht zu einem Ausdruck

en: Symbol at %L is not a DUMMY variable
de: Symbol bei %L ist keine Scheinvariable

en: Synonym for -Wcomment
de: Synonym für -Wcomment

en: Syntax error in !$OMP THREADPRIVATE list at %C
de: Syntaxfehler in !$OMP THREADPRIVATE Liste bei %C

en: Syntax error in %s statement at %C
de: Syntaxfehler in Anweisung %s bei %C

en: Syntax error in ABSTRACT INTERFACE statement at %C
de: Syntaxfehler in ABSTRACT INTERFACE-Anweisung bei %C

en: Syntax error in ASYNCHRONOUS statement at %C
de: Syntaxfehler in ASYNCHRONOUS-Anweisung bei %C

en: Syntax error in CHARACTER declaration at %C
de: Syntaxfehler in CHARACTER-Deklaration bei %C

en: Syntax error in COMPLEX constant at %C
de: Syntaxfehler in COMPLEX-Konstante bei %C

en: Syntax error in ENUMERATOR definition at %C
de: Syntaxfehler in ENUMERATOR-Definition bei %C

en: Syntax error in EQUIVALENCE statement at %L
de: Syntaxfehler in EQUIVALENCE-Anweisung bei %L

en: Syntax error in FORALL iterator at %C
de: Syntaxfehler in FORALL-Iterator bei %C

en: Syntax error in I/O iterator at %C
de: Syntaxfehler in E/A-Iterator bei %C

en: Syntax error in IF-clause at %C
de: Syntaxfehler in IF-Klausel bei %C

en: Syntax error in IF-expression at %C
de: Syntaxfehler in IF-Ausdruck bei %C

en: Syntax error in IMPORT statement at %C
de: Syntaxfehler in IMPORT-Anweisung bei %C

en: Syntax error in NAME= specifier for binding label at %C
de: Syntaxfehler in NAME=-Spezifikation für Bindungsmarke bei %C

en: Syntax error in OpenMP variable list at %C
de: Syntaxfehler in OpenMP-Variablenliste bei %C

en: Syntax error in PROCEDURE statement at %C
de: Syntaxfehler in PROCEDURE-Anweisung bei %C

en: Syntax error in PROTECTED statement at %C
de: Syntaxfehler in PROTECTED-Anweisung bei %C

en: Syntax error in SAVE statement at %C
de: Syntaxfehler in SAVE-Anweisung bei %C

en: Syntax error in SUBSTRING specification at %C
de: Syntaxfehler in SUBSTRING-Spezifikation bei %C

en: Syntax error in VALUE statement at %C
de: Syntaxfehler in VALUE-Anweisung bei %C

en: Syntax error in VOLATILE statement at %C
de: Syntaxfehler in VOLATILE-Anweisung bei %C

en: Syntax error in argument list at %C
de: Syntaxfehler in Argumentliste bei %C

en: Syntax error in array constructor at %C
de: Syntaxfehler in Feldkonstruktor bei %C

en: Syntax error in character length specification at %C
de: Syntaxfehler in Zeichenlängenangabe bei %C

en: Syntax error in common block name at %C
de: Syntaxfehler im allgemeinen Blocknamen bei %C

en: Syntax error in data declaration at %C
de: Syntaxfehler in Daten-Deklaration bei %C

en: Syntax error in expression at %C
de: Syntaxfehler in Ausdruck bei %C

en: Syntax error in generic specification at %C
de: Syntaxfehler in allgemeiner Spezifikation bei %C

en: Syntax error in iterator at %C
de: Syntaxfehler in Iterator bei %C

en: Syntax error in procedure pointer component at %C
de: Syntaxfehler in Prozedurzeiger-Komponente bei %C

en: Syntax error in structure constructor at %C
de: Syntaxfehler in Strukturkonstruktor bei %C

en: Syntax error: Trailing garbage in END INTERFACE statement at %C
de: Syntaxfehler: Nachfolgender Überschuss in END INTERFACE-Anweisung bei %C

en: Syntax error: Trailing garbage in INTERFACE statement at %C
de: Syntaxfehler: Nachfolgender Überschuss in INTERFACE-Anweisung bei %C

en: THREADPRIVATE object '%s' in %s clause at %L
de: THREADPRIVATE - Objekt »%s« in Klausel %s bei %L

en: THREADPRIVATE object '%s' in SHARED clause at %L
de: THREADPRIVATE - Objekt »%s« in Klausel SHARED bei %L

en: Taken at least once:%s of %d
de: %s von %d Zweigen mindestens einmal genommen

en: Target DFLOAT double precision code
de: Ziel: DFLOAT Code mit doppelter Genauigkeit

en: Target has split I&D
de: Ziel hat geteiltes I&D

en: Target of rank remapping is too small (%ld < %ld)
de: Ziel für neue Rangabbildung ist zu klein (%ld < %ld)

en: Target the AM33 processor
de: Auf AM33-Prozessor abzielen

en: Target the AM33/2.0 processor
de: Auf AM33/2.0-Prozessor abzielen

en: Target the AM34 processor
de: Auf AM34-Prozessor abzielen

en: Target: %s
de: Ziel: %s

en: The --param option recognizes the following as parameters
de: Die Option »--param« erkennt die folgenden Parameter

en: The ABI for passing parameters with %d-byte alignment has changed in GCC 4.6
de: Das ABI der Parameterübergabe mit %d-Byte-Ausrichtung hat sich in GCC 4.6 geändert

en: The CHARACTER elements of the array constructor at %L must have the same length (%d/%d)
de: Die CHARACTER-Elemente des Feldkonstruktors bei %L müssen die gleiche Länge haben (%d/%d)

en: The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L
de: Der DEFAULT CASE bei %L kann nicht von zweitem DEFAULT CASE bei %L gefolgt werden

en: The Hollerith constant at %L is too long to convert to %s
de: Hollerith-Konstante bei %L ist zu lang zum Konvertieren in %s

en: The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer
de: Das INTENT(OUT)-Scheinargument »%s« bei %L hat vermutete Größe und kann damit keine Standardinitialisierung haben

en: The argument list functions %%VAL, %%LOC or %%REF are not allowed in this context at %L
de: Die Argumentlistenfunktionen %%VAL, %%LOC oder %%REF bei %L sind in diesem Kontext nicht erlaubt

en: The derived type '%s' at %L is of type '%s', which has not been defined
de: Der abgeleitete Typ »%s« bei %L hat Typ »%s«, der nicht definiert wurde

en: The earliest MacOS X version on which this program will run
de: Die älteste MacOSX-Version, auf der dieses Programm laufen wird

en: The element in the derived type constructor at %L, for pointer component '%s' should be a POINTER or a TARGET
de: Das Element im Konstruktor abgeleiteten Typs bei %L für Zeigerkomponente »%s« sollte ein POINTER oder ein TARGET sein

en: The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s
de: Das Element in Konstruktor abgeleiteten Typs bei %L für Zeigerkomponente »%s« ist %s, sollte aber %s sein

en: The equivalence set for '%s' cause an invalid extension to COMMON '%s' at %L
de: Die Äquivalenzmenge für »%s« bewirkt eine ungültige Erweiterung für COMMON »%s« bei %L

en: The equivalence set for variable '%s' declared at %L violates alignment requirements
de: Die Äquivalenzmenge für bei %2$L deklarierte Variable »%1$s« verletzt Ausrichtungsanforderungen

en: The following options are language-independent
de: Die folgenden Optionen sind sprach-unabhängig

en: The following options are language-related
de: Die folgenden Optionen sind sprachbezogen

en: The following options are not documented
de: Die folgenden Optionen sind nicht dokumentiert

en: The following options are specific to just the language
de: Die folgenden Optionen sind nur spezifisch für die Sprache

en: The following options are supported by the language
de: Die folgenden Optionen werden von der Sprache unterstützt

en: The following options are target specific
de: Die folgenden Optionen sind zielspezifisch

en: The following options control compiler warning messages
de: Die folgenden Optionen steuern Warnmeldungen des Compilers

en: The following options control optimizations
de: Die folgenden Optionen steuern Optimierungen

en: The following options take joined arguments
de: Die folgenden Optionen verwenden gemeinsame Argumente

en: The following options take separate arguments
de: Die folgenden Optionen verwenden separate Argumente

en: The impure variable at %L is assigned to a derived type variable with a POINTER component in a PURE procedure (12.6)
de: Die unreine Variable bei %L wird einer Variable abgeleiteten Typs mit einer POINTER-Komponente in einer PURE-Prozedur zugewiesen (12.6)

en: The lower bound for a buffer to be considered for stack smashing protection
de: Untere Schranke für einen für Stack-Smashing-Protection betrachteten Puffer

en: The maximum amount of memory to be allocated by GCSE
de: Maximalbetrag des von GCSE zu belegenden Speichers

en: The maximum conflict delay for an insn to be considered for speculative motion
de: Höchste Verzögerung bei Konflikt, sodass Befehl für spekulative Bewegung in Betracht kommt

en: The maximum depth of a loop nest we completely peel
de: Die maximale Tiefe einer Schleifenschachtelung, die vollständig geschält wird

en: The maximum depth of recursive inlining for inline functions
de: Größte Tiefe mit rekursivem Inline für Inline-Funktionen

en: The maximum depth of recursive inlining for non-inline functions
de: Größte Tiefe mit rekursivem Inline für Nicht-Inline-Funktionen

en: The maximum expansion factor when copying basic blocks
de: Der höchste Erweiterungsfaktor beim Kopieren von Basisblöcken

en: The maximum instructions CSE process before flushing
de: Die Höchstzahl der von CSE verarbeiteten Anweisungen vor dem Rücksetzen

en: The maximum length of path considered in cse
de: Größte Länge des betrachteten Pfades in cse

en: The maximum length of scheduling's pending operations list
de: Die Maximallänge der Liste der anhängigen geplanten Operationen

en: The maximum memory locations recorded by cselib
de: Höchstzahl der Speicherstellen, die von cselib aufgezeichnet werden

en: The maximum number of RTL nodes that can be recorded as combiner's last value
de: Höchstzahl der RTL-Knoten, die als letzte Werte des Kombinierers aufgezeichnet werden können

en: The maximum number of blocks in a region to be considered for interblock scheduling
de: Höchstzahl der für Zwischen-Block-Scheduling zu betrachtenden Blöcke in einer Region

en: The maximum number of incoming edges to consider for crossjumping
de: Höchstzahl der zu betrachtenden eingehenden Kanten für Kreuzsprung

en: The maximum number of insns in a region to be considered for interblock scheduling
de: Höchstzahl der für Zwischen-Block-Scheduling zu betrachtenden Anweisungen in einer Region

en: The maximum number of insns of a completely peeled loop
de: Die Höchstzahl der Befehle einer vollständig geschälten Schleife

en: The maximum number of insns of a peeled loop
de: Die Höchstzahl der Befehle einer geschälten Schleife

en: The maximum number of insns of a peeled loop that rolls only once
de: Die Höchstzahl der Befehle einer geschälten Schleife, die nur einmal rollt

en: The maximum number of insns of an unswitched loop
de: Die Höchstzahl der Befehle einer ungeschalteten Schleife

en: The maximum number of insns to duplicate when unfactoring computed gotos
de: Die Höchstzahl der zu vervielfältigenden Anweisungen, wenn berechnete Gotos expandiert werden

en: The maximum number of instructions in a single function eligible for inlining
de: Die Höchstzahl der Anweisungen in einer einzelnen für »inline« geeigneten Funktion

en: The maximum number of instructions inline function can grow to via recursive inlining
de: Die Höchstzahl der Anweisungen, bis zu der eine Inline-Funktion per Rekursion wachsen kann

en: The maximum number of instructions non-inline function can grow to via recursive inlining
de: Die Höchstzahl der Anweisungen, bis zu der eine Nicht-Inline-Funktion per Rekursion wachsen kann

en: The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass
de: Höchstzahl der vom Scheduler während der ersten Planphase fertig zur Ausführung zu betrachtenden Anweisungen

en: The maximum number of instructions to consider to fill a delay slot
de: Die Höchstzahl der zu betrachtenden Anweisungen um Verzögerungsschlitz zu füllen

en: The maximum number of instructions to consider to find accurate live register information
de: Die Höchstzahl der zu betrachtenden Anweisungen um richtige aktive Registerinformationen zu finden

en: The maximum number of instructions to consider to unroll in a loop
de: Die Höchstzahl der zum Abrollen von Schleifen zu betrachtenden Anweisungen

en: The maximum number of instructions to consider to unroll in a loop on average
de: Die Höchstzahl der zum Abrollen von Schleifen im Mittel zu betrachtenden Anweisungen

en: The maximum number of instructions to search backward when looking for equivalent reload
de: Höchstzahl der rückwärts zu suchenden Anweisungen, wenn nach äquivalentem Neuladen gesucht wird

en: The maximum number of instructions when automatically inlining
de: Die Höchstzahl der Anweisungen für automatisches »inline«

en: The maximum number of iterations through CFG to extend regions
de: Höchstzahl der Iterationen durch CFG zur Regionserweiterung

en: The maximum number of loop iterations we predict statically
de: Die Höchstzahl der Schleifendurchläufe, die statisch vorhergesagt werden

en: The maximum number of nested indirect inlining performed by early inliner
de: Die Höchstzahl von geschachteltem indirekten »inline« wurde bereits durch früheres »inline« durchgeführt

en: The maximum number of peelings of a single loop
de: Die Höchstzahl der Schälvorgänge einer einzelnen Schleife

en: The maximum number of peelings of a single loop that is peeled completely
de: Die Höchstzahl der Schälvorgänge einer einzelnen Schleife, die vollständig geschält wird

en: The maximum number of unrollings of a single loop
de: Die Höchstzahl der Iterationen zum Abrollen in einzelner Schleife

en: The maximum number of unswitchings in a single loop
de: Die Höchstzahl der Abschaltungen in einer einzelnen Schleife

en: The maximum ratio between array size and switch branches for a switch conversion to take place
de: Maximales Verhältnis zwischen Feldgröße und Switch-Zweigen, wobei Switch-Umwandlung erfolgt

en: The maximum ratio of insertions to deletions of expressions in GCSE
de: Das größte Verhältnis von Einfügungen zu Löschungen von Ausdrücken in GCSE

en: The maximum size of the lookahead window of selective scheduling
de: Maximale Größe des Vorgriffsfensters der wählbaren Planung

en: The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.
de: Die Mindestwahrscheinlichkeit für spekulativen Erfolg (in Prozent), sodass spekulativer Befehl eingeplant wird

en: The minimum UID to be used for a nondebug insn
de: Kleinste UID für Nicht-Debug-Befehl

en: The minimum cost of an expensive expression in the loop invariant motion
de: Die Mindestkosten eines teuren Ausdrucks in der Schleifeninvariantenbewegung

en: The minimum number of matching instructions to consider for crossjumping
de: Mindestanzahl der passenden zu betrachtenden Anweisungen für Kreuzsprung

en: The minimum probability of reaching a source block for interblock speculative scheduling
de: Die Mindestwahrscheinlichkeit für das Erreichen eines Quellblockes für spekulatives Zwischen-Block-Scheduling

en: The module or main program array '%s' at %L must have constant shape
de: Das Feld »%s« im Modul oder Hauptprogramm bei %L muss konstante Form haben

en: The name '%s' at %C has already been used as an external module name.
de: Der Name »%s« bei %C wurde bereits als ein externer Modulname verwendet.

en: The name '%s' cannot be used as a defined operator at %C
de: Der Name »%s« bei %C kann nicht als ein definierter Operator verwendet werden

en: The number of cycles the swing modulo scheduler considers when checking conflicts using DFA
de: Anzahl der Zyklen, die der Swing-Modulo-Scheduler bei Konfliktprüfung mit DFA betrachtet

en: The number of insns executed before prefetch is completed
de: Die Anzahl der ausgeführten Befehle bevor Prefetch abgeschlossen ist

en: The number of prefetches that can run at the same time
de: Die Anzahl der Prefetches, die gleichzeitig laufen können

en: The number of registers in each class kept unused by loop invariant motion
de: Die Anzahl der Register in jeder Klasse, die von Schleifeninvariantenbewegung freigehalten werden

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available
de: Prozentsatz der Funktion, gewichtet nach Ausführungsfrequenz, die bei Verfolgungsentwurf abgedeckt werden muss. Verwendet, wenn Profil-Rückmeldung verfügbar ist

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available
de: Prozentsatz der Funktion, gewichtet nach Ausführungsfrequenz, die bei Verfolgungsentwurf abgedeckt werden muss. Verwendet, wenn Profil-Rückmeldung nicht verfügbar ist

en: The pointer component '%s' of '%s' at %L is a type that has not been declared
de: Die Zeigerkomponente »%s« bei »%s« bei %L hat nicht deklarierten Typ

en: The rank of the element in the derived type constructor at %L does not match that of the component (%d/%d)
de: Der Rang des Elements im Konstruktor abgeleiteten Typs bei %L passt nicht zu dem der Komponente (%d/%d)

en: The resolution file
de: Die Datei mit den Auflösungen

en: The size of L1 cache
de: Die Größe des L1-Caches

en: The size of L1 cache line
de: Die Größe einer L1-Cacheline

en: The size of L2 cache
de: Die Größe des L2-Caches

en: The size of function body to be considered large
de: Die Größe eines als groß angesehenen Funktionskörpers

en: The size of stack frame to be considered large
de: Die Größe eines als groß angesehenen Stack-Rahmens

en: The size of translation unit to be considered large
de: Die Größe einer als groß angesehenen Übersetzungseinheit

en: The threshold ratio between current and hottest structure counts
de: Der Anteil-Schwellwert zwischen aktuellen und heißesten Strukturzahlen

en: The threshold ratio for performing partial redundancy elimination after reload
de: Der Anteil-Schwellwert für die Ausführung partieller Redundanzbeseitigung nach dem Neuladen

en: The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload
de: Der Anteil-Schwellwert des Ausführungszählers kritischer Kanten, die Redundanzbeseitigung nach dem Neuladen erlauben

en: The type '%s' cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L
de: Der Typ %s kann bei %L nicht mit Wirt verbunden werden, da er von unverträglichem bei %L definiertem Objekt mit gleichem Namen blockiert wird

en: The type for function '%s' at %L is not accessible
de: Der Typ für Funktion »%s« bei %L ist nicht erreichbar

en: The upper bound for sharing integer constants
de: Obere Schranke zum gemeinsamen Verwenden von Ganzzahlkonstanten

en: The upper bound in the last dimension must appear in the reference to the assumed size array '%s' at %L
de: Die obere Schranke in der letzten Dimension muss in der Referenz auf das Feld »%s« vermuteter Größe bei %L auftreten

en: The value of n in -finit-character=n must be between 0 and 127
de: Der Wert von n in -finit-character=n muss zwischen 0 und 127 liegen

en: There is already a procedure with binding name '%s' for the derived type '%s' at %C
de: Es gibt bereits eine Prozedur mit Bindungsname »%s« für den abgeleiteten Typ »%s« bei %C

en: There is no specific function for the generic '%s' at %L
de: Es gibt keine spezifische Funktion für das allgemeine »%s« bei %L

en: There is no specific subroutine for the generic '%s' at %L
de: Es gibt kein spezifisches Unterprogramm für allgemeines »%s« bei %L

en: There's already a non-generic procedure with binding name '%s' for the derived type '%s' at %C
de: Es gibt bereits eine nicht-generische Prozedur mit Bindungsname »%s« für den abgeleiteten Typ »%s« bei %C

en: This is free software; see the source for copying conditions.
    There is NO warranty; not even for MERCHANTABILITY or 
    FITNESS FOR A PARTICULAR PURPOSE.
de: Dies ist freie Software; die Kopierbedingungen stehen in den Quellen. Es
    gibt KEINE Garantie; auch nicht für MARKTGÄNGIGKEIT oder FÜR SPEZIELLE ZWECKE.

en: This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
de: Dies ist freie Software; die Kopierbedingungen stehen in den Quellen. Es
    gibt KEINE Garantie; auch nicht für MARKTGÄNGIGKEIT oder FÜR SPEZIELLE ZWECKE.

en: This switch is deprecated; use -Werror=implicit-function-declaration instead
de: Dieser Schalter ist veraltet; stattdessen -Werror=implicit-function-declaration verwenden

en: This switch is deprecated; use -Wextra instead
de: Dieser Schalter ist veraltet; stattdessen -Wextra verwenden

en: This switch lacks documentation
de: Dieser Schalter ist undokumentiert

en: Thread model: %s
de: Thread-Modell: %s

en: Threadprivate at %L isn't SAVEd
de: Threadprivate bei %L ist nicht SAVEd

en: Threadprivate variable at %C is an element of a COMMON block
de: Threadprivate Variable bei %C ist ein Element eines COMMON-Blocks

en: Throttle unrolling to avoid thrashing target registers unless the unroll benefit outweighs this
de: Unrolling drosseln, um die Zerstörung der Zielregister zu vermeiden, es sei denn, das Unrolling überwiegt dies

en: Thumb-1 hard-float VFP ABI
de: Thumb-1 Hardware-Gleitkomma VFP ABI

en: Thumb: Assume function pointers may go to non-Thumb aware code
de: Thumb: Annahme, dass Funktionszeiger an nicht Thumb unterstützenden Code übergeben werden können

en: Thumb: Assume non-static functions may be called from ARM code
de: Thumb: Annahme, dass nichtstatische Funktionen von ARM-Code aus aufgerufen werden können

en: Thumb: Generate (leaf) stack frames even if not needed
de: Thumb: Blatt-Stapelrahmen erzeugen, auch wenn nicht erforderlich

en: Thumb: Generate (non-leaf) stack frames even if not needed
de: Thumb: Nicht-Blatt-Stapelrahmen erzeugen, auch wenn nicht erforderlich

en: To enable preprocessing, use -cpp
de: Zum Einschalten der Vorverarbeitung -cpp verwenden

en: Together with -fpic and -fPIC, do not use GOTPLT references
de: Keine GOTPLT-Referenzen zusammen mit -fpic und -fPIC verwenden

en: Toggle -fvar-tracking-assignments
de: -fvar-tracking-assignments umschalten

en: Toggle debug information generation
de: Erzeugung von Fehlersuchinformationen umschalten

en: Too few codimensions at %C, expected %d not %d
de: Zu wenige Codimensionen bei %C, %d statt %d erwartet

en: Too few elements in expression for SUB= argument at %L
de: Zu wenige Elemente in Ausdruck für SUB= Argument bei %L

en: Too many arguments in call to '%s' at %L
de: Zu viele Argumente in Aufruf von »%s« bei %L

en: Too many arguments to %s at %L
de: Zu viele Argumente für %s bei %L

en: Too many digits in statement label at %C
de: Zu viele Ziffern in Anweisungsmarke bei %C

en: Too many elements in expression for SUB= argument at %L
de: Zu viele Elemente in Ausdruck für SUB= Argument bei %L

en: Transform condition stores into unconditional ones
de: Bedingte Speicherbefehle in unbedingte umwandeln

en: Trap for signed overflow in addition, subtraction and multiplication
de: Vorzeichenbehafteten Überlauf in Addition, Subtraktion und Multiplikation abfangen (»trap«)

en: Trap on integer divide by zero
de: Ganzzahldivision durch Null abfangen

en: Treat all warnings as errors
de: Alle Warnungen als Fehler behandeln

en: Treat lines with 'D' in column one as comments
de: Zeilen mit »D« in Spalte eins als Kommentar behandeln

en: Treat missing header files as generated files
de: Fehlende Header-Dateien als generierte Dateien behandeln

en: Treat signed overflow as undefined
de: Vorzeichenbehafteten Überlauf als undefiniert behandeln

en: Treat specified warning as error
de: Angegebene Warnung als Fehler behandeln

en: Treat the input file as already preprocessed
de: Die Eingabedatei als bereits vorverarbeitet behandeln

en: Try 'jcf-dump --help' for more information.
de: »jcf-dump --help« für mehr Informationen verwenden.

en: Try running '%s' in the shell to raise its limit.
de: »%s« in der Shell könnte diese Beschränkung erhöhen.

en: Try to allow the linker to turn PIC calls into direct calls
de: Dem Linker erlauben, PIC-Aufrufe in direkte Aufrufe umzuwandeln

en: Try to convert virtual calls to direct ones.
de: Versuchen, virtuelle Sprünge in direkte umzuwandeln.

en: Try to lay out derived types as compactly as possible
de: Versuchen, abgeleitete Typen so kompakt wie möglich anzuordnen

en: Tune code for the given processor
de: Code auf angegebenen Prozessor abstimmen

en: Tune expected memory latency
de: Die erwartete Speicher-Wartezeit abstimmen

en: Tune for the specified target CPU or architecture
de: Für angegebene Ziel-CPU oder Architektur optimieren

en: Two main PROGRAMs at %L and %C
de: Zwei Haupt-PROGRAMme bei %L und %C

en: Two or more part references with nonzero rank must not be specified at %L
de: Zwei oder mehr Teilreferenzen mit Rang größer Null dürfen nicht bei %L angegeben werden

en: Type '%s' at %L is a parameter to the BIND(C) procedure '%s' but is not C interoperable because derived type '%s' is not C interoperable
de: Typ »%s« bei %L ist ein Parameter für die BIND(C)-Prozedur »%s«, jedoch nicht interoperabel mit C, da der abgeleitete Typ »%s« nicht mit C interoperabel ist

en: Type '%s' containing DEFERRED binding at %C is not ABSTRACT
de: Typ »%s« mit DEFERRED-Bindung bei %C ist nicht ABSTRACT

en: Type declaration '%s' at %L is not C interoperable but it is BIND(C)
de: Typdeklaration »%s« bei %L ist nicht C-kompatibel, aber sie ist BIND(C)

en: Type mismatch in argument '%s' at %L; passed %s to %s
de: Unpassender Typ in Argument »%s« bei %L; übergab %s an %s

en: Type name '%s' at %C cannot be the same as an intrinsic type
de: Typname »%s« bei %C kann nicht der gleiche wie ein intrinsischer Typ sein

en: Type name '%s' at %C is ambiguous
de: Typname »%s« bei %C ist mehrdeutig

en: Type of argument '%s' in call to '%s' at %L should be %s, not %s
de: Typ des Arguments »%s« in Aufruf von »%s« bei %L sollte %s sein, nicht %s

en: Type specified for intrinsic function '%s' at %L is ignored
de: Für intrinsische Funktion »%s« angegebener Typ bei %L wird ignoriert

en: Type-spec at %L cannot contain a deferred type parameter
de: Typspezifikation bei %L kann keine Parameter mit aufgeschobenem Typ haben

en: UNIT specification at %L must be an INTEGER expression or a CHARACTER variable
de: UNIT-Spezifikation bei %L muss ein INTEGER-Ausdruck oder eine CHARACTER-Variable sein

en: Unable to find a specific INTRINSIC procedure for the reference '%s' at %L
de: Spezifische INTRINSIC-Prozedur für Referenz »%s« bei %L kann nicht gefunden werden

en: Unable to resolve the specific function '%s' at %L
de: Spezifische Funktion »%s« bei %L kann nicht aufgelöst werden

en: Unable to resolve the specific subroutine '%s' at %L
de: Spezifisches Unterprogramm »%s« bei %L kann nicht aufgelöst werden

en: Unclassifiable OpenMP directive at %C
de: Nicht klassifizierbare OpenMP-Anweisung bei %C

en: Unclassifiable statement at %C
de: Nicht klassifizierbare Anweisung bei %C

en: Unclassifiable statement in IF-clause at %C
de: Anweisung in IF-Klausel bei %C nicht klassifizierbar

en: Under -ffast-math, generate a FRIZ instruction for (double)(long long) conversions
de: Unter -ffast-math, einen FRIZ-Befehl für (double)(long long)-Umwandlungen erzeugen

en: Unequal character lengths (%ld/%ld) in %s
de: Ungleiche Zeichenlängen (%ld/%ld) in %s

en: Unequal character lengths (%ld/%ld) in %s at %L
de: Ungleiche Zeichenlängen (%ld, %ld) in %s bei %L

en: Unexpected %s statement at %C
de: Unerwartete Anweisung %s bei %C

en: Unexpected %s statement at %C in INTERFACE body
de: Unerwartete Anweisung %s bei %C in INTERFACE-Körper

en: Unexpected %s statement in BLOCK DATA at %C
de: Unerwartete Anweisung %s in BLOCK DATA bei %C

en: Unexpected %s statement in CONTAINS section at %C
de: Unerwartete Anweisung %s in CONTAINS-Abschnitt bei %C

en: Unexpected %s statement in FORALL block at %C
de: Unerwartete Anweisung %s in FORALL-Block bei %C

en: Unexpected %s statement in INTERFACE block at %C
de: Unerwartete Anweisung %s in INTERFACE-Block bei %C

en: Unexpected %s statement in MODULE at %C
de: Unerwartete Anweisung %s in MODULE bei %C

en: Unexpected %s statement in WHERE block at %C
de: Unerwartete Anweisung %s in WHERE-Block bei %C

en: Unexpected '*' for codimension %d of %d at %C
de: Unerwartetes '*' für Codimension %d von %d bei %C

en: Unexpected '*' in coarray subscript at %C
de: Unerwartetes '*' in Coarray-Index bei %C

en: Unexpected CASE statement at %C
de: Unerwartete CASE-Anweisung bei %C

en: Unexpected END statement at %C
de: Unerwartete END-Anweisung bei %C

en: Unexpected EOF
de: Unerwartetes EOF

en: Unexpected alternate return spec in subroutine call at %L
de: Unerwartete alternative Rückgabespezifikation in Unterprogrammaufruf bei %L

en: Unexpected character in variable list at %C
de: Unerwartetes Zeichen in Variablenliste bei %C

en: Unexpected characters in PARAMETER statement at %C
de: Unerwartete Zeichen in PARAMETER-Anweisung bei %C

en: Unexpected coarray designator at %C
de: Unerwarteter Coarray-Bezeichner bei %C

en: Unexpected element '%c' in format string at %L
de: Unerwartetes Element »%c« in Formatzeichenkette bei %L

en: Unexpected end of file in '%s'
de: Unerwartetes Dateiende in »%s«

en: Unexpected end of format string
de: Unerwartetes Ende der Formatzeichenkette

en: Unexpected end of module
de: Unerwartetes Modulende

en: Unexpected end of module in string constant
de: Unerwartetes Modulende in Zeichenkettenkonstante

en: Unexpected junk after ELSE IF statement at %C
de: Unerwartete Zeichen hinter ELSE-IF-Anweisung bei %C

en: Unexpected junk after ELSE statement at %C
de: Unerwartete Zeichen hinter ELSE-Anweisung bei %C

en: Unexpected junk after function declaration at %C
de: Unerwartete Angaben hinter Funktionsdeklaration bei %C

en: Unexpected junk in formal argument list at %C
de: Unerwartete Angaben in formaler Argumentliste bei %C

en: Unexpected type in truthvalue_conversion
de: Unerwarteter Typ in Wahrheitswert-Umwandlung

en: Unexpected type in write_state_scalar_type
de: Unerwarteter Typ in write_state_scalar_type

en: Unexpected type in write_state_string_type
de: Unerwarteter Typ in write_state_string_type

en: Unexpected type...
de: Unerwarteter Typ...

en: Unexpected use of subroutine name '%s' at %C
de: Unerwartete Verwendung des Unterprogrammnamens »%s« bei %C

en: Unit number in I/O statement too large
de: Einheitszahl in E/A-Anweisung zu groß

en: Unit number in I/O statement too small
de: Einheitszahl in E/A-Anweisung zu klein

en: Unknown argument list function at %L
de: Unbekannte Argumentlistenfunktion bei %L

en: Unknown intrinsic op
de: unbekannte innere Anweisung

en: Unknown operator '%s' at %%L
de: Unbekannter Operator »%s« bei %%L

en: Unlimited polymorphism at %C not yet supported
de: Unbegrenzter Polymorphismus bei %C wird noch nicht unterstützt

en: Unrecognized option to -finit-logical: %s
de: Nicht erkannte Option für -finit-logical: %s

en: Unrecognized option to -finit-real: %s
de: Nicht erkannte Option für -finit-real: %s

en: Unsupported statement inside WHERE at %L
de: Nicht unterstützte Anweisung in WHERE bei %L

en: Unterminated character constant beginning at %C
de: Unbeendete Zeichenkonstante beginnend bei %C

en: Unused dummy argument '%s' at %L
de: Ungenutztes Scheinargument %s bei %L

en: Unused parameter '%s' declared at %L
de: Ungenutzter Parameter »%s« bei %L deklariert

en: Unused variable '%s' declared at %L
de: Ungenutzte Variable »%s« bei %L deklariert

en: Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d
de: Obere Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d

en: Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d
de: Obere Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d

en: Upper bound of last coarray dimension must be '*' at %C
de: Obere Grenze der letzten Coarray-Dimension muss '*' bei %C sein

en: Usage: %s [OPTIONS]... CLASSNAMEmain [OUTFILE]
de: Aufruf: %s [OPTIONEN]... KLASSENNAMEmain [AUSGABEDATEI]

en: Usage: %s [options] file...
de: Aufruf: %s [Optionen] Datei...

en: Usage: gcov [OPTION]... SOURCEFILE...
de: Aufruf: gcov [OPTION]... QUELLDATEI...

en: Usage: jcf-dump [OPTION]... CLASS...
de: Aufruf: jcf-dump [OPTION]... KLASSE...

en: Use "-Wa,OPTION" to pass "OPTION" to the assembler.
de: »-Wa,OPTION« verwenden, um »OPTION« an den Assembler zu übergeben.

en: Use "-Wl,OPTION" to pass "OPTION" to the linker.
de: »-Wl,OPTION« verwenden, um »OPTION« an den Linker zu übergeben.

en: Use -G for data that is not defined by the current object
de: -G für Daten verwenden, die nicht von aktuellem Objekt definiert wurden

en: Use -G for object-local data
de: -G für Objekt-lokale Daten verwenden

en: Use 128-bit long double
de: 128-bit long double verwenden

en: Use 16 bit int
de: 16-Bit int verwenden

en: Use 32 bit float
de: 32-Bit float verwenden

en: Use 32 bit int
de: 32-Bit int verwenden

en: Use 32-bit ABI
de: 32-Bit-ABI verwenden

en: Use 32-bit floating-point registers
de: 32-Bit-Gleitkommaregister verwenden

en: Use 32-bit general registers
de: Allgemeine Register in 32 Bit Breite verwenden

en: Use 4 byte entries in switch tables
de: 4-Byte-Einträge in switch-Tabellen verwenden

en: Use 4 media accumulators
de: 4 Media-Register verwenden

en: Use 4xx half-word multiply instructions
de: 4xx Halbwort-Multiplikationsbefehle verwendet

en: Use 4xx string-search dlmzb instruction
de: 4xx Befehl zur Zeichenkettensuche dlmzb verwenden

en: Use 64 FPRs
de: 64 FPRs verwenden

en: Use 64 GPRs
de: 64 GPRs verwenden

en: Use 64 bit float
de: 64-Bit float verwenden

en: Use 64-bit ABI
de: 64-Bit-ABI verwenden

en: Use 64-bit floating-point registers
de: 64-Bit-Gleitkommaregister verwenden

en: Use 64-bit general registers
de: Allgemeine Register in 64 Bit Breite verwenden

en: Use 64-bit long double
de: 64-bit long double verwenden

en: Use 8 media accumulators
de: 8 Media-Register verwenden

en: Use ABI reserved registers
de: ABI-reservierte Register verwenden

en: Use AltiVec instructions
de: AltiVec-Befehle verwenden

en: Use Bionic C library
de: Bionic-C-Bibliothek verwenden

en: Use Branch Likely instructions, overriding the architecture default
de: »Branch Likely«-Befehle verwenden, Standard für die Architektur überschreiben

en: Use CONST16 instruction to load constants
de: CONST16-Befehle zum Laden von Konstanten verwenden

en: Use EABI
de: EABI verwenden

en: Use GNU C library
de: GNU-C-Bibliothek verwenden

en: Use GP relative sdata/sbss sections
de: Relative GP sdata/sbss-Abschnitte verwenden

en: Use GP-relative addressing to access small data
de: GP-relative Adressierung verwenden, auf um kleine Daten zuzugreifen

en: Use H8/300 alignment rules
de: H8/300-Ausrichtungsregeln verwenden

en: Use IEEE math for fp comparisons
de: IEEE-Arithmetik für Gleitkommavergleiche verwenden

en: Use IRA based register pressure calculation
de: IRA-basierte Registerdruckkalkulation verwenden

en: Use MIPS-3D instructions
de: MIPS-3D-Befehle verwenden

en: Use MIPS-DSP REV 2 instructions
de: MIPS-DSP-Befehle REV 2 verwenden

en: Use MIPS-DSP instructions
de: MIPS-DSP-Befehle verwenden

en: Use Mingw-specific thread support
de: Mingw-spezifische Thread-Unterstützung verwenden

en: Use Neon quad-word (rather than double-word) registers for vectorization
de: Neon-Quad-Word (statt Double-Word) Register für Vektorisierung verwenden

en: Use NewABI-style %reloc() assembly operators
de: %reloc()-Assembleroperatoren im NewABI-Stil verwenden

en: Use P-mnemonics for branches statically predicted as taken
de: P-Mnemonics für statisch als verfolgt vorhergesehene Zweige verwenden

en: Use PMC-style 'mad' instructions
de: »mad«-Befehle im PMC-Stil verwenden

en: Use POWER instruction set
de: POWER-Befehlssatz verwenden

en: Use POWER2 instruction set
de: POWER2-Befehlssatz verwenden

en: Use PowerPC General Purpose group optional instructions
de: Optionale Befehle der PowerPC-Mehrzweck-Gruppe verwenden

en: Use PowerPC Graphics group optional instructions
de: Optionale Befehle der PowerPC-Grafik-Gruppe verwenden

en: Use PowerPC V2.01 single field mfcr instruction
de: PowerPC V2.01 Einzelfeld-mfcr-Befehl verwenden

en: Use PowerPC V2.02 floating point rounding instructions
de: PowerPC V2.02 Gleitkomma-Rundungsbefehle verwenden

en: Use PowerPC V2.02 popcntb instruction
de: PowerPC V2.02 popcntb-Befehl verwenden

en: Use PowerPC V2.05 compare bytes instruction
de: PowerPC V2.05 Bytevergleichs-Befehl verwenden

en: Use PowerPC V2.06 popcntd instruction
de: PowerPC V2.06 popcntb-Befehl verwenden

en: Use PowerPC instruction set
de: PowerPC-Befehlssatz verwenden

en: Use PowerPC-64 instruction set
de: PowerPC-64-Befehlssatz verwenden

en: Use ROM instead of RAM
de: ROM statt RAM verwenden

en: Use SSE register passing conventions for SF and DF mode
de: SSE-Register-Übergabekonventionen für SF- und DF-Modus verwenden

en: Use SmartMIPS instructions
de: SmartMIPS-Befehle verwenden

en: Use UNIX assembler syntax
de: UNIX-Assemblersyntax verwenden

en: Use UltraSPARC Visual Instruction Set extensions
de: Visuelle Befehlssatzerweiterungen für UltraSPARC verwenden

en: Use VAX fp
de: VAX-FP verwenden

en: Use VAXC structure conventions
de: VAXC-Strukturkonventionen verwenden

en: Use __cxa_atexit to register destructors
de: __cxa_atexit verwenden, um Destruktoren zu registrieren

en: Use __cxa_get_exception_ptr in exception handling
de: __cxa_get_exception_ptr in Ausnahmebehandlung verwenden

en: Use a 32-bit long type
de: Einen 32-Bit-»long«-Typ verwenden

en: Use a 4-byte record marker for unformatted files
de: Eine 4-Byte-Datensatzmarkierung für unformatierte Dateien verwenden

en: Use a 64-bit long type
de: Einen 64-Bit-»long«-Typ verwenden

en: Use a stack protection method for every function
de: Eine Stapelschutzmethode für jede Funktion verwenden

en: Use addresses that allocate global registers
de: Globale Register belegende Adressen verwenden

en: Use alternate register names
de: Alternative Registernamen verwenden

en: Use an 8-bit 'int' type
de: 8-Bit-»int«-Typ verwenden

en: Use an 8-byte record marker for unformatted files
de: Eine 8-Byte-Datensatzmarkierung für unformatierte Dateien verwenden

en: Use arbitrary sized immediates in bit operations
de: Direktwerte beliebiger Größen in Bit-Operationen zulassen

en: Use big-endian byte order
de: Big-Endian Byte-Reihenfolge verwenden

en: Use big-endian format for unformatted files
de: Big-Endian-Format für unformatierte Dateien verwenden

en: Use branch-and-break sequences to check for integer divide by zero
de: Sprung-und-Abbruch-Sequenzen verwenden, um auf Ganzzahldivision durch Null zu prüfen

en: Use bras for executable < 64k
de: bras für ausführbare Datei < 64k verwenden

en: Use call and rtc for function calls and returns
de: Aufruf und RTC für Funktionsaufrufe und Rückgaben verwenden

en: Use call-clobbered registers for parameters and return value
de: Mit Aufruf verbundene Register für Parameter und Rückgabewerte verwenden

en: Use control speculation
de: Steuerungsspekulation verwenden

en: Use data speculation after reload
de: Datenspekulation nach Neuladen verwenden

en: Use data speculation before reload
de: Datenspekulation vor Neuladen verwenden

en: Use decimal floating point instructions
de: Dezimale Gleitkommabefehle verwenden

en: Use default method for sdata handling
de: Standardmethode für sdata-Behandlung verwenden

en: Use different calling convention using 'rtd'
de: Andere Aufrufkonvention mit 'RTD' verwenden

en: Use direct addressing mode for soft registers
de: Modus zur direkten Adressierung für Soft-Register verwenden

en: Use direct references against %gs when accessing tls data
de: Direkte Referenzen gegen %gs beim Zugriff auf TLS-Daten verwenden

en: Use epsilon-respecting floating point compare instructions
de: Epsilon beachtende Gleitkomma-Vergleichsbefehle verwenden

en: Use expression value profiles in optimizations
de: Profile von Ausdruckswerten in Optimierungen verwenden

en: Use extended PowerPC V2.05 move floating point to/from GPR instructions
de: Erweiterte Befehle zum Kopieren von Gleitkomma zu/von GPR bei PowerPC V2.05 verwenden

en: Use f2c calling convention
de: f2c-Aufrufkonvention verwenden

en: Use features of and schedule code for given CPU
de: Eigenschaften der gegebenen CPU verwenden und entsprechend Code planen

en: Use features of and schedule given CPU
de: Für angegebene CPU planen und deren Eigenschaften verwenden

en: Use fp double instructions
de: Gleitkomma-double-Befehle verwenden

en: Use fp registers
de: FP-Register verwenden

en: Use given SPARC-V9 code model
de: Gegebenes SPARC-V9-Codemodell verwenden

en: Use given assembler dialect
de: Gegebenen Assemblerdialekt verwenden

en: Use given thread-local storage dialect
de: Gegebenen Thread-lokalen Speicherdialekt verwenden

en: Use given x86-64 code model
de: Gegebenes x86-64-Codemodell verwenden

en: Use hardware FP
de: Hardware-FP verwenden

en: Use hardware division instructions on ColdFire
de: Hardware-Divisionsbefehle auf Coldfire verwenden

en: Use hardware floating point
de: Hardware-Gleitkomma verwenden

en: Use hardware floating point conversion instructions
de: Hardware-Gleitkommakonvertierungbefehle verwenden

en: Use hardware floating point instructions
de: Hardware-Gleitkommabefehle verwenden

en: Use hardware floating point square root instruction
de: Verwendet Hardware-Gleitkomma-Wurzel-Instruktion

en: Use hardware fp
de: Hardware-FP verwenden

en: Use hardware quad FP instructions
de: Hardware-Vierfach-Gleitkommabefehle verwenden

en: Use in block control speculation
de: Steuerungsspekulation im Block verwenden

en: Use in block data speculation after reload
de: Datenspekulation im Block nach Neuladen verwenden

en: Use in block data speculation before reload
de: Datenspekulation im Block vor Neuladen verwenden

en: Use in/loc/out register names
de: in/loc/out-Registernamen ausgeben

en: Use indirect CALLXn instructions for large programs
de: Indirekte CALLXn-Befehle für große Programme verwenden

en: Use indirect calls
de: Indirekte Aufrufe verwenden

en: Use inline patterns for copying memory
de: Inline-Muster beim Speicherkopieren verwenden

en: Use jsr and rts for function calls and returns
de: JSR und RTS für Funktionsaufrufe und Rückgaben verwenden

en: Use jump tables for sufficiently large switch statements
de: Sprungtabellen für hinreichend große switch-Anweisungen verwenden

en: Use little-endian byte order
de: Little-Endian Byte-Reihenfolge verwenden

en: Use little-endian format for unformatted files
de: Little-Endian-Format für unformatierte Dateien verwenden

en: Use ll, sc and sync instructions
de: Befehle ll, sc und sync verwenden

en: Use media instructions
de: Media-Befehle verwenden

en: Use multiply add/subtract instructions
de: Befehle zum Multiplizieren-Addieren/Subtrahieren verwenden

en: Use multiply high instructions for high part of 32x32 multiply
de: Verwendet »multiply high«-Befehle für den oberen Teil einer 32x32 Multiplikation

en: Use native (MS) bitfield layout
de: MS-Bitfeld-Anordnung verwenden

en: Use native format for unformatted files
de: Das eigene Format für unformatierte Dateien verwenden

en: Use new adddi3/subdi3 patterns
de: Neue adddi3/subdi3-Muster verwenden

en: Use new mnemonics for PowerPC architecture
de: Neue Mnemonics für PowerPC-Architektur verwenden

en: Use normal calling convention
de: Normale Aufrufkonvention verwenden

en: Use of -fdefault-double-8 requires -fdefault-real-8
de: Verwendung von -fdefault-double-8 erfordert -fdefault-real-8

en: Use of intrinsic module '%s' at %C conflicts with non-intrinsic module name used previously
de: Verwendung des intrinsischen Moduls »%s« bei »%C« steht mit nicht-intrinsischem vorher verwendeten Modulnamen in Konflikt

en: Use of non-intrinsic module '%s' at %C conflicts with intrinsic module name used previously
de: Verwendung des nicht-intrinsischen Moduls »%s« bei %C steht mit vorher verwendetem intrinsischen Modulnamen in Konflikt

en: Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %C is incompatible with option %s
de: Verwendung der Konstante NUMERIC_STORAGE_SIZE aus intrinsischem Modul ISO_FORTRAN_ENV bei %C ist mit Option %s unverträglich

en: Use offset tables for virtual method calls
de: Offset-Tabellen für virtuelle Methodenaufrufe verwenden

en: Use old mnemonics for PowerPC architecture
de: Alte Mnemonics für PowerPC-Architektur verwenden

en: Use only one TOC entry per procedure
de: Nur einen TOC-Eintrag pro Prozedur verwenden

en: Use packed stack layout
de: Gepacktes Stacklayout verwenden

en: Use paired-single floating-point instructions
de: Paarweise-single Gleitkommabefehle verwenden

en: Use pattern compare instructions
de: Verwendet Mustervergleichsbefehle

en: Use portable calling conventions
de: Portierbare Aufrufkonventionen verwenden

en: Use profiling information for branch probabilities
de: Profilierungsinformationen für Verzweigungswahrscheinlichkeiten verwenden

en: Use propolice as a stack protection method
de: Propolice als Stapelschutzmethode verwenden

en: Use push instructions to save outgoing arguments
de: Push-Befehle verwenden, um ausgehende Argumente zu sichern

en: Use red-zone in the x86-64 code
de: Rote Zone in x86-64-Code verwenden

en: Use register stack for parameters and return value
de: Registerstapel für Parameter und Rückgabewerte verwenden

en: Use registers for argument passing
de: Register zur Argumentübergabe verwenden

en: Use registers r2 and r5
de: Register r2 und r5 verwenden

en: Use rjmp/rcall (limited range) on >8K devices
de: rjmp/rcall (beschränkter Wertebereich) auf >8K-Geräten verwenden

en: Use sdram version of runtime
de: SDRAM-Version der Laufzeitumgebung verwenden

en: Use shared libraries
de: Shared Libraries verwenden

en: Use simple data speculation check
de: Einfachen Datenspekulationstest verwenden

en: Use simple data speculation check for control speculation
de: Einfachen Datenspekulationstest für Steuerungsspekulation verwenden

en: Use simulator runtime
de: Simulator-Laufzeitumgebung verwenden

en: Use simulator runtime without vectors
de: Simulator-Laufzeitumgebung ohne Vektoren verwenden

en: Use software emulation for floating point (default)
de: Software-Gleitkomma verwenden (Standard)

en: Use software floating point
de: Software-Gleitkomma verwenden

en: Use stack bias
de: Stapelversatz verwenden

en: Use standard main function as entry for startup
de: Die Standard-main-Funktion als Einsprungpunkt zum Starten verwenden

en: Use structs on stronger alignment for double-word copies
de: Bei stärkerer Ausrichtung für Doppelwort-Kopien Structs verwenden

en: Use stubs for function prologues
de: Stubs für Funktionsprologe verwenden

en: Use subroutines for function prologues and epilogues
de: Für Funktionsprologe und -epiloge Unterprogramme verwenden

en: Use synci instruction to invalidate i-cache
de: synci-Befehl verwenden, um i-Cache ungültig zu machen

en: Use table lookup optimization for small signed integer divisions
de: Verwende Tabellen als Optimierung für die Division kleiner vorzeichenbehafteter Ganzzahlen

en: Use the Cray Pointer extension
de: Die Cray-Zeiger-Erweiterung verwenden

en: Use the DEC assembler syntax
de: DEC-Assemblersyntax verwenden

en: Use the GNU extension to the PE format for aligned common data
de: GNU-Erweiterung für PE-Format für ausgerichtete gemeinsame Daten verwenden

en: Use the RTL dead code elimination pass
de: Den RTL-Schritt zur Entfernung toten Codes verwenden

en: Use the RTL dead store elimination pass
de: Den RTL-Schritt zur Entfernung toter Speicherbereiche verwenden

en: Use the bit-field instructions
de: Bit-Feld-Befehle verwenden

en: Use the divide instruction
de: Divisionsbefehl verwenden

en: Use the hardware barrel shifter instead of emulation
de: Verwendet den Hardware-Berrelshifter statt der Emulation

en: Use the mips-tfile postpass
de: Die mips-tfile Nachbearbeitung verwenden

en: Use the most feature-enabling options allowed by other options
de: Die meisten Optionen verwenden, die spezielle Fähigkeiten einschalten, solange sie durch andere Optionen erlaubt sind

en: Use the narrowest integer type possible for enumeration types
de: Den schmalstmöglichen Ganzzahltyp für Aufzählungstypen verwenden

en: Use the same size for double as for float
de: Für double die gleiche Breite wie für float verwenden

en: Use the simulator runtime.
de: Simulator-Laufzeitumgebung verwenden

en: Use the soft multiply emulation (default)
de: Verwendet die Software-Multiplikationsemulation (Vorgabe)

en: Use the software emulation for divides (default)
de: Verwendet die Softwareemulation für Divisionen (Vorgabe)

en: Use traditional GNU semantics for inline functions
de: Traditionelle GNU-Semantik für Inline-Funktionen verwenden

en: Use trap instructions to check for integer divide by zero
de: Trap-Befehle verwenden, um auf Ganzzahldivision durch Null zu prüfen

en: Use uClibc C library
de: uClibc-C-Bibliothek verwenden

en: Use unicode startup and define UNICODE macro
de: Unicode-Start verwenden und UNICODE-Makro definieren

en: Use vector/scalar (VSX) instructions
de: Vektor-/skalare (VSX) Befehle verwenden

en: Use zero-extending memory loads, not sign-extending ones
de: Nullerweiternde Speicherladungen verwenden, nicht vorzeichenerweiternde

en: Used in Fix-and-Continue mode to indicate that object files may be swapped in at runtime
de: Im Fix-and-Continue-Modus verwendet, um anzuzeigen, dass Objektdateien zur Laufzeit eingetauscht werden können (»swap«)

en: User defined non-ELEMENTAL function '%s' at %L not allowed in WORKSHARE construct
de: Benutzerdefinierte nicht-elementare Funktion »%s« bei %L ist in WORKSHARE-Konstrukt nicht erlaubt

en: User operator '%s' referenced at %L not found in module '%s'
de: Bei %2$L referenzierter Benutzeroperator »%1$s« nicht im Modul »%3$s« gefunden

en: User operator procedure '%s' at %L cannot be assumed character length
de: Prozedur für Benutzeroperator »%s« bei %L kann nicht vermutete Zeichenlänge haben

en: User operator procedure '%s' at %L must be a FUNCTION
de: Prozedur für Benutzeroperator »%s« bei %L muss eine FUNKTION sein

en: User operator procedure '%s' at %L must have at least one argument
de: Prozedur für Benutzeroperator »%s« bei %L muss mindestens ein Argument haben

en: Using built-in specs.
de: Es werden eingebaute Spezifikationen verwendet.

en: VALUE is not allowed inside of BLOCK at %C
de: VALUE ist in BLOCK bei %C nicht erlaubt

en: VDEF and VUSE do not use the same symbol
de: VDEF und VUSE verwenden nicht das selbe Symbol

en: VLIW functions are not allowed without a VLIW configuration
de: VLIW-Funktionen ohne VLIW-Konfiguration sind nicht erlaubt

en: VOIDmode on an output
de: VOIDmode bei einer Ausgabe

en: VSX and E500 instructions cannot coexist
de: VSX- und E500-Befehle können nicht koexistieren

en: Variable '%s' at %C cannot be redefined inside loop beginning at %L
de: Variable »%s« bei %C kann nicht innerhalb der bei %L beginnenden Schleife redefiniert werden

en: Variable '%s' at %C with an initializer already appears in a DATA statement
de: Variable »%s« bei %C mit Initialisierung tritt bereits in einer DATA-Anweisung auf

en: Variable '%s' at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope
de: Variable »%s« bei %L kann nicht BIND(C) sein, weil es weder ein COMMON-Block noch mit Sichtbarkeit auf Modulebene deklariert ist

en: Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes
de: Variable »%s« bei %L kann nicht gleichzeitig die Attribute ALLOCATABLE und BIND(C) haben

en: Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes
de: Variable »%s« bei %L kann nicht gleichzeitig die Attribute POINTER und BIND(C) haben

en: Variable '%s' at %L cannot have the ALLOCATABLE attribute because procedure '%s' is BIND(C)
de: Variable »%s« bei %L kann nicht Attribut ALLOCATABLE haben, da Prozedur »%s« BIND(C) ist

en: Variable '%s' at %L cannot have the OPTIONAL attribute because procedure '%s' is BIND(C)
de: Variable »%s« bei %L kann kein OPTIONAL-Attribut haben, da Prozedur »%s« BIND(C) ist

en: Variable '%s' at %L cannot have the POINTER attribute because procedure '%s' is BIND(C)
de: Variable »%s« bei %L kann kein POINTER-Attribut haben, da Prozedur »%s« BIND(C) ist

en: Variable '%s' at %L has not been assigned a format label
de: Variable »%s« bei %L wurde keine Formatmarke zugewiesen

en: Variable '%s' at %L in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is bind(c)
de: Variable »%s« bei %L in Common-Block »%s« bei %C muss in einer C-kompatiblen Art deklariert sein, da Common-Block »%s« bind(c) ist

en: Variable '%s' at %L in this context must be constant
de: Variable »%s« bei %L muss in diesem Kontext eine Konstante sein

en: Variable '%s' at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components
de: Variable '%s' bei %L ist INTENT(OUT) und kann daher kein reservierbares Coarray sein oder Coarray-Komponenten haben

en: Variable '%s' at %L is a coarray or has a coarray component and is not ALLOCATABLE, SAVE nor a dummy argument
de: Variable »%s« bei %L ist ein Koarray oder hat eine Koarraykomponente und ist weder ALLOCATABLE, SAVE, noch ein Scheinargument

en: Variable '%s' at %L is a parameter to the BIND(C) procedure '%s' but may not be C interoperable
de: Variable »%s« bei %L ist ein Parameter für die BIND(C)-Prozedur »%s«, könnte jedoch inkompatibel mit C sein

en: Variable '%s' at %L is in COMMON but only in BLOCK DATA initialization is allowed
de: Variable »%s« bei %L ist in COMMON, aber Initialisierung ist nur in BLOCK DATA erlaubt

en: Variable '%s' at %L may not be a C interoperable kind but it is bind(c)
de: Variable »%s« bei %L könnte mit C inkompatibel sein, aber sie ist BIND(C)

en: Variable '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray
de: Variable »%s« bei %L mit TYPE(C_PTR) oder TYPE(C_FUNPTR) sollte kein Koarray sein

en: Variable '%s' at %L with coarray component shall be a nonpointer, nonallocatable scalar
de: Variable »%s« bei %L mit Koarraykomponente sollte ein Nichtzeiger, nichtallozierbares Skalar sein

en: Variable '%s' cannot appear in the expression at %L
de: Variable »%s« kann nicht im Ausdruck bei %L auftreten

en: Variable '%s' has not been assigned a target label at %L
de: Variable »%s« wurde keine Zielmarke bei %L zugewiesen

en: Variable '%s' in %s clause is used in NAMELIST statement at %L
de: Variable »%s« in Klausel %s wird in NAMELIST-Anweisung bei %L verwendet

en: Variable '%s' in common block '%s' at %C can not be bind(c) since it is not global
de: Variable »%s« in Common-Block »%s« bei %C kann nicht bind(c) sein, da sie nicht global ist

en: Variable '%s' in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is BIND(C)
de: Variable »%s« in gemeinsamem Block »%s« bei %C muss mit einer mit C interoperablen Art deklariert sein, da der gemeinsame Block »%s« BIND(C) ist

en: Variable '%s' in common block '%s' at %L cannot be declared with BIND(C) since it is not a global
de: Variable »%s« in gemeinsamem Block »%s« bei %L kann nicht mit BIND(C) deklariert werden da sie nicht global ist

en: Variable '%s' in common block '%s' at %L may not be a C interoperable kind though common block '%s' is BIND(C)
de: Variable »%s« in gemeinsamem Block »%s« bei %L könnte inkompatibel mit C sein, obwohl gemeinsamer Block »%s« BIND(C) ist

en: Variable '%s' is used at %L before the ENTRY statement in which it is a parameter
de: Variable »%s« wird bei %L vor Anweisung ENTRY verwendet, in der sie ein Parameter ist

en: Variable '%s', used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter
de: In Spezifikationsausdruck verwendete Variable »%s« wird bei %L vor Anweisung ENTRY referenziert, in der sie ein Parameter ist

en: Variable type is UNKNOWN in assignment at %L
de: Unbekannter Variablentyp in Zuweisung bei %L

en: Variables this size and smaller go in the based section. (default 0)
de: Variablen dieser Größe und kleiner gehen in die basierte Sektion. (Standard: 0)

en: Variables this size and smaller go in the tiny section. (default 4)
de: Variablen dieser Größe und kleiner gehen in den »tiny«-Abschnitt. (Standard: 4)

en: Vector library ABI to use
de: Zu verwendendes Vektorbibliotheks-ABI

en: WHERE assignment target at %L has inconsistent shape
de: WHERE-Zuweisungsziel bei %L hat ungültige Form

en: WHERE mask at %L has inconsistent shape
de: WHERE-Maske bei %L hat ungültige Form

en: WHERE/ELSEWHERE clause at %L requires a LOGICAL array
de: Klausel WHERE/ELSEWHERE bei %L erfordert ein LOGICAL-Feld

en: Warn about "extern" declarations not at file scope
de: Bei »extern«-Deklarationen außerhalb des Dateisichtbarkeitsbereiches warnen

en: Warn about "suspicious" constructs
de: Bei »verdächtigen« Konstrukten warnen

en: Warn about @selector()s without previously declared methods
de: Bei @selector() ohne vorher deklarierte Methoden warnen

en: Warn about C constructs that are not in the common subset of C and C++
de: Bei C-Konstrukten, die nicht in gemeinsamer Teilmenge von C und C++ sind, warnen

en: Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 200x
de: Bei C++-Konstrukten, deren Bedeutung sich zwischen ISO C++ 1998 und ISO C++ 200x unterscheidet, warnen

en: Warn about NULL being passed to argument slots marked as requiring non-NULL
de: Warnen, wenn NULL an Argumentstellen, die als nicht-NULL erfordernd markiert sind, übergeben wird

en: Warn about PCH files that are found but not used
de: Bei PCH-Dateien, die gefunden, aber nicht benutzt werden, warnen

en: Warn about alignment of COMMON blocks
de: Bei Ausrichtung von COMMON-Blöcken warnen

en: Warn about all enumerated switches missing a specific case
de: Bei aufgezählten »switch«-Anweisungen, denen ein bestimmter Fall fehlt, warnen

en: Warn about an empty body in an if or else statement
de: Bei leerem Körper in einer if- oder else-Anweisung warnen

en: Warn about called procedures not explicitly declared
de: Bei Aufrufen nicht explizit deklarierter Prozeduren warnen

en: Warn about calls with implicit interface
de: Bei Aufrufen mit impliziter Schnittstelle warnen

en: Warn about casting functions to incompatible types
de: Warnen, wenn Funktionen in unverträgliche Typen umgewandelt werden

en: Warn about casts which discard qualifiers
de: Bei Umwandlungen, die Qualifizierer streichen, warnen

en: Warn about code which might break strict aliasing rules
de: Bei Code warnen, der strict-aliasing-Regeln verletzen könnte

en: Warn about comparison of different enum types
de: Beim Vergleich verschiedener Enum-Typen warnen

en: Warn about compile-time integer division by zero
de: Bei Ganzzahldivisionen durch Null zur Übersetzungszeit warnen

en: Warn about constructs not instrumented by -fmudflap
de: Bei nicht von -fmudflap instrumentierten Konstrukten warnen

en: Warn about creation of array temporaries
de: Bei Erzeugung temporärer Felder warnen

en: Warn about deprecated 'vector long ...' AltiVec type usage
de: Vor der Verwendung des veralteten AltiVec-Typen »vector long ...« warnen

en: Warn about enumerated switches missing a "default:" statement
de: Bei aufgezählten »switch«-Anweisungen ohne »default«-Anweisung warnen

en: Warn about enumerated switches, with no default, missing a case
de: Bei aufgezählten »switch«-Anweisungen ohne »default«, denen ein Fall fehlt, warnen

en: Warn about features not present in traditional C
de: Bei Merkmalen, die in traditionellem C nicht verfügbar sind, warnen

en: Warn about format strings that are not literals
de: Bei Formatstrings, die keine Literale sind, warnen

en: Warn about format strings that contain NUL bytes
de: Bei Formatstrings, die NUL-Bytes enthalten, warnen

en: Warn about function parameters declared without a type specifier in K&R-style functions
de: Bei ohne Typspezifizierung in Funktionen im K&R-Stil deklarierten Funktionsparametern warnen

en: Warn about function pointer arithmetic
de: Bei Arithmetik mit Funktionszeigern warnen

en: Warn about functions which might be candidates for __attribute__((const))
de: Bei Funktionen, die Kandidaten für __attribute__((const)) sein könnten, warnen

en: Warn about functions which might be candidates for __attribute__((noreturn))
de: Bei Funktionen, die Kandidaten für __attribute__((noreturn)) sind, warnen

en: Warn about functions which might be candidates for __attribute__((pure))
de: Bei Funktionen, die Kandidaten für __attribute__((pure)) sein könnten, warnen

en: Warn about functions which might be candidates for format attributes
de: Bei Funktionen, die Kandidaten für Formatattribute sein könnten, warnen

en: Warn about global functions without previous declarations
de: Vor globalen Funktionen ohne vorherige Deklaration warnen

en: Warn about global functions without prototypes
de: Bei globalen Funktionen ohne Prototypen warnen

en: Warn about implicit conversions from "float" to "double"
de: Bei impliziten Umwandlungen von "float" nach "double" warnen

en: Warn about implicit declarations
de: Bei impliziten Deklarationen warnen

en: Warn about implicit function declarations
de: Bei impliziten Funktionsdeklarationen warnen

en: Warn about inappropriate attribute usage
de: Bei unpassender Attributverwendung warnen

en: Warn about invalid uses of the "offsetof" macro
de: Bei ungültigen Benutzungen des Makros »offsetof« warnen

en: Warn about macros defined in the main file that are not used
de: Bei in der Hauptdatei definierten, ungenutzten Makros warnen

en: Warn about missing ampersand in continued character constants
de: Bei fehlendem kaufmännischen Und in fortgesetzten Zeichenkonstanten warnen

en: Warn about missing fields in struct initializers
de: Bei fehlenden Feldern in struct-Initialisierungen warnen

en: Warn about misuses of pragmas
de: Bei Pragmamissbrauch warnen

en: Warn about most implicit conversions
de: Bei den meisten impliziten Umwandlungen warnen

en: Warn about multiple declarations of the same object
de: Bei mehreren Deklarationen des gleichen Objektes warnen

en: Warn about non-virtual destructors
de: Bei nicht-virtuellen Destruktoren warnen

en: Warn about none ISO msvcrt scanf/printf width extensions
de: Bei fehlenden ISO msvcrt scanf/printf Breiten-Erweiterungen warnen

en: Warn about optimizations that assume that signed overflow is undefined
de: Bei Optimierungen, die annehmen, dass vorzeichenbehafteter Überlauf undefiniert ist, warnen

en: Warn about overflow in arithmetic expressions
de: Bei Überlauf in arithmetischen Ausdrücken warnen

en: Warn about overloaded virtual function names
de: Bei überladenen virtuellen Funktionsnamen warnen

en: Warn about overriding initializers without side effects
de: Beim Überschreiben von Initialisierungen ohne Seiteneffekte warnen

en: Warn about pointer casts which increase alignment
de: Warnen, wenn Zeigerumwandlungen die Ausrichtung vergrößern

en: Warn about possible aliasing of dummy arguments
de: Bei möglichem Aliasing von Dummy-Argumenten warnen

en: Warn about possible security problems with format functions
de: Vor möglichen Sicherheitsproblemen mit Formatfunktionen warnen

en: Warn about possible violations of sequence point rules
de: Bei möglichen Verstößen gegen Sequenzpunktregeln warnen

en: Warn about possibly missing braces around initializers
de: Bei möglicherweise fehlenden Klammern um Initialisierungen warnen

en: Warn about possibly missing parentheses
de: Bei möglicherweise fehlenden Klammern warnen

en: Warn about possibly nested block comments, and C++ comments spanning more than one physical line
de: Bei möglicherweise geschachtelten Blockkommentaren und C++-Kommentaren, die mehr als eine physikalische Zeile umfassen, warnen

en: Warn about printf/scanf/strftime/strfmon format string anomalies
de: Bei Unregelmäßigkeiten in printf/scanf/strftime/strfmon-Formatstrings warnen

en: Warn about returning structures, unions or arrays
de: Bei zurückgegebenen Strukturen, Unions oder Feldern warnen

en: Warn about signed-unsigned comparisons
de: Bei Vergleichen von vorzeichenbehaftet mit vorzeichenlos warnen

en: Warn about stray tokens after #elif and #endif
de: Bei verirrten Symbolen hinter #elif und #endif warnen

en: Warn about strftime formats yielding 2-digit years
de: Bei strftime-Formaten, die auf Jahreszahlen mit 2 Stellen hinweisen, warnen

en: Warn about subscripts whose type is "char"
de: Vor Indizes mit Typ »char« warnen

en: Warn about suspicious declarations of "main"
de: Vor verdächtigen Deklarationen von »main« warnen

en: Warn about suspicious uses of memory addresses
de: Vor verdächtigem Gebrauch von Speicheradressen warnen

en: Warn about things that will change when compiling with an ABI-compliant compiler
de: Bei Dingen, die sich bei der Übersetzung mit einem ABI-konformen Compiler ändern werden, warnen

en: Warn about truncated character expressions
de: Bei abgeschnittenen Zeichenausdrücken warnen

en: Warn about truncated source lines
de: Bei abgeschnittenen Quelltextzeilen warnen

en: Warn about uncasted NULL used as sentinel
de: Bei als Wächter verwendetem, nicht umgewandeltem NULL warnen

en: Warn about underflow of numerical constant expressions
de: Bei Unterlauf numerischer Konstantenausdrücke warnen

en: Warn about uninitialized automatic variables
de: Bei nicht initialisierten automatischen Variablen warnen

en: Warn about unprototyped function declarations
de: Bei Funktionsdeklarationen ohne Prototyp warnen

en: Warn about unrecognized pragmas
de: Bei nicht erkannten Pragmas warnen

en: Warn about unsuffixed float constants
de: Bei Gleitkommakonstanten ohne Suffix warnen

en: Warn about unused dummy arguments.
de: Bei nicht verwendeten Dummy-Argumenten warnen

en: Warn about use of multi-character character constants
de: Bei Verwendung von Zeichenkonstanten mit mehreren Zeichen warnen

en: Warn about user-specified include directories that do not exist
de: Bei durch den Benutzer angegebenen Einfügepfaden, die nicht vorhanden sind, warnen

en: Warn about uses of __attribute__((deprecated)) declarations
de: Bei Verwendungen von Deklarationen mit __attribute__((deprecated)) warnen

en: Warn about variables that might be changed by "longjmp" or "vfork"
de: Bei Variablen, die von »longjmp« oder »vfork« geändert werden könnten, warnen

en: Warn about variables which are initialized to themselves
de: Bei Variablen, die mit sich selbst initialisiert werden, warnen

en: Warn about violations of Effective C++ style rules
de: Bei Verstößen gegen die Stil-Richtlinien von »Effective C++« warnen

en: Warn about zero-length formats
de: Bei Formaten der Länge null warnen

en: Warn for converting NULL from/to a non-pointer type
de: Warnen bei Umwandlung von NULL in Nicht-Zeiger-Typ oder umgekehrt

en: Warn for implicit type conversions between signed and unsigned integers
de: Bei impliziten Typumwandlungen zwischen vorzeichenbehafteten und vorzeichenlosen Ganzzahlen warnen

en: Warn for implicit type conversions that may change a value
de: Bei impliziten Typumwandlungen warnen, die einen Wert ändern könnten

en: Warn for obsolescent usage in a declaration
de: Bei veralteter Verwendung in einer Deklaration warnen

en: Warn if .class files are out of date
de: Warnen, wenn .class-Dateien veraltet sind

en: Warn if a C-style cast is used in a program
de: Warnen, wenn eine Typumwandlung im C-Stil im Programm verwendet wird

en: Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value
de: Warnen, wenn der Rückgabewert der mit dem Attribut warn_unused_result definierten Funktion ignoriert wird

en: Warn if a comparison is always true or always false due to the limited range of the data type
de: Warnen, wenn ein Vergleich durch beschränkten Wertebereich des Datentyps stets »wahr« oder »unwahr« ist

en: Warn if a deprecated compiler feature, class, method, or field is used
de: Warnen, wenn veraltetes Compiler-Merkmal, Klasse, Methode oder Feld verwendet wird

en: Warn if a function uses alloca or creates an array with dynamic size
de: Warnen, wenn eine Funktion alloca verwendet oder ein Feld dynamischer Größe erzeugt

en: Warn if a property for an Objective-C object has no assign semantics specified
de: Warnen, wenn die Eigenschaft eines Ojective-C Objektes keine Zuweisungssemantik spezifiert

en: Warn if a selector has multiple methods
de: Warnen, wenn ein Selektor mehrere Methoden hat

en: Warn if a single function's framesize exceeds the given framesize
de: Warnen, wenn Rahmengröße einer einzelnen Funktion die gegebene Rahmengröße überschreitet

en: Warn if a string is longer than the maximum portable length specified by the standard
de: Warnen, wenn Zeichenkette länger als größte vom Standard angegebene portable Länge ist

en: Warn if a user-procedure has the same name as an intrinsic
de: Warnen, wenn eine Benutzer-Prozedur den selben Namen wie ein Intrinsic hat

en: Warn if a variable length array is used
de: Warnen, wenn ein Feld veränderbarer Länge verwendet wird

en: Warn if an array is accessed out of bounds
de: Warnen, wenn auf ein Feld außerhalb der Grenzen zugegriffen wird

en: Warn if an old-style parameter definition is used
de: Warnen, wenn eine Parameterdefinition im alten Stil verwendet wird

en: Warn if an undefined macro is used in an #if directive
de: Warnen, wenn ein undefiniertes Makro in einer #if-Anweisung verwendet wird

en: Warn if constant CFString objects contain non-portable characters
de: Warnen, wenn konstante CFString-Objekte unportierbare Zeichen enthalten

en: Warn if deprecated empty statements are found
de: Warnen, wenn veraltete Leeranweisungen gefunden werden

en: Warn if inherited methods are unimplemented
de: Warnen, wenn geerbte Methoden nicht implementiert sind

en: Warn if modifiers are specified when not necessary
de: Bei unnötig angegebenen Modifizierern warnen

en: Warn if passing too many arguments to a function for its format string
de: Bei zu vielen Argumenten für eine Funktion (anhand Formatzeichenkette) warnen

en: Warn if testing floating point numbers for equality
de: Bei Test von Gleitkommawerten auf Gleichheit warnen

en: Warn if the loop cannot be optimized due to nontrivial assumptions.
de: Warnen, wenn Schleife wegen nichttrivialer Annahmen nicht optimiert werden kann.

en: Warn if trigraphs are encountered that might affect the meaning of the program
de: Warnen, wenn Trigraphs auftreten, die die Bedeutung des Programmes beeinflussen könnten

en: Warn if type signatures of candidate methods do not match exactly
de: Wenn Typsignaturen der Kandidatenmethoden nicht exakt passen, warnen

en: Warn in case profiles in -fprofile-use do not match
de: Warnen, wenn Profile in -fprofile-use nicht zueinander passen

en: Warn of prototypes causing type conversions different from what would happen in the absence of prototype
de: Bei Prototypen, die zu Typumwandlungen führen, warnen, wenn sich diese vom Fall ohne Prototypen unterscheiden

en: Warn on intrinsics not part of the selected standard
de: Bei im gewählten Standard nicht vorhandenen Intrinsics warnen

en: Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used
de: Warnen, wenn die eingebauten Funktionen __sync_fetch_and_nand und __sync_nand_and_fetch verwendet werden

en: Warn when a #warning directive is encountered
de: Warnen, wenn eine #warning-Anweisung verwendet wird

en: Warn when a Cell microcoded instruction is emitted
de: Warnen, wenn mikrocodierte Cell-Befehle ausgegeben werden

en: Warn when a declaration does not specify a type
de: Warnen, wenn eine Deklaration keinen Typ angibt

en: Warn when a declaration is found after a statement
de: Warnen, wenn eine Deklaration hinter einer Anweisung gefunden wird

en: Warn when a function is unused
de: Warnen, wenn eine Funktion ungenutzt bleibt

en: Warn when a function parameter is only set, otherwise unused
de: Warnen, wenn ein Funktionsparameter zwar gesetzt aber nicht verwendet wird

en: Warn when a function parameter is unused
de: Warnen, wenn ein Funktionsparameter nicht verwendet wird

en: Warn when a jump misses a variable initialization
de: Warnen, wenn ein Sprung die Initialisierung einer Variable überspringt

en: Warn when a label is unused
de: Warnen, wenn eine Marke ungenutzt bleibt

en: Warn when a logical operator is suspiciously always evaluating to true or false
de: Warnen, wenn ein logischer Operator verdächtigerweise immer zu »wahr« oder »falsch« auswertet

en: Warn when a pointer differs in signedness in an assignment
de: Warnen, wenn sich ein Zeiger im Vorzeichenbesitz in einer Zuweisung unterscheidet

en: Warn when a pointer is cast to an integer of a different size
de: Bei Typkonvertierung von Zeiger auf Ganzzahl anderer Breite warnen

en: Warn when a register variable is declared volatile
de: Warnen, wenn Registervariable als »volatile« deklariert ist

en: Warn when a variable is only set, otherwise unused
de: Warnen, wenn eine Variable zwar gesetzt aber nicht verwendet wird

en: Warn when a variable is unused
de: Warnen, wenn eine Variable nicht verwendet wird

en: Warn when all constructors and destructors are private
de: Warnen, wenn alle Konstruktoren und Destruktoren privat sind

en: Warn when an expression value is unused
de: Warnen, wenn ein Ausdruckswert nicht verwendet wird

en: Warn when an inlined function cannot be inlined
de: Warnen, wenn eine inline-Funktion nicht als solche erzeugt werden kann

en: Warn when an optimization pass is disabled
de: Warnen, wenn ein Optimierungsdurchgang ausgeschaltet ist

en: Warn when converting the type of pointers to member functions
de: Bei Umwandlung des Typs von Zeigern auf Elementfunktionen warnen

en: Warn when non-templatized friend functions are declared within a template
de: Warnen, wenn Nicht-Template-Friend-Funktionen innerhalb eines Templates angegeben werden

en: Warn when not issuing stack smashing protection for some reason
de: Warnen, wenn Stackzerstörungsschutz nicht ausgegeben wird

en: Warn when one local variable shadows another
de: Warnen, wenn eine lokale Variable eine andere überdeckt

en: Warn when overload promotes from unsigned to signed
de: Warnen, wenn Überladung von vorzeichenbehaftet zu vorzeichenlos führt

en: Warn when padding is required to align structure members
de: Warnen, wenn Auffüllen benötigt wird, um Strukturelemente auszurichten

en: Warn when the compiler reorders code
de: Warnen, wenn der Compiler Code umsortiert

en: Warn when the packed attribute has no effect on struct layout
de: Warnen, wenn das »packed«-Attribut keine Auswirkung auf Strukturanordnung hat

en: Warn when there is a cast to a pointer from an integer of a different size
de: Bei Typumwandlung in Zeiger von Ganzzahl anderer Breite warnen

en: Warn whenever a function's return type defaults to "int" (C), or about inconsistent return types (C++)
de: Bei Standardrückgabetyp »int« für Funktionen (C) und inkonsistenten Rückgabetypen (C++) warnen

en: Warn whenever a trampoline is generated
de: Warnen, wenn ein Trampolin generiert wird

en: Warn whenever an Objective-C assignment is being intercepted by the garbage collector
de: Immer warnen, wenn eine Objective-C-Zuweisung vom Garbage Collector abgefangen wird

en: Warn whenever type qualifiers are ignored.
de: Warnen, wenn Typqualifizierer ignoriert werden.

en: Warning:
de: Warnung:

en: When "signed" or "unsigned" is not given make the bitfield signed
de: Wenn »signed« und »unsigned« nicht angegeben wurden, das Bitfeld vorzeichenbehaftet machen

en: When "signed" or "unsigned" is not given make the bitfield unsigned
de: Wenn »signed« und »unsigned« nicht gegeben sind, das Bitfeld vorzeichenlos machen

en: When generating -mabicalls code, allow executables to use PLTs and copy relocations
de: Bei Erzeugung von »-mabicalls«-Code den ausführbaren Dateien erlauben, PLTs und Kopierauslagerungen zu verwenden

en: When generating -mabicalls code, make the code suitable for use in shared libraries
de: Bei Erzeugung von -mabicalls - Code den Code für gemeinsam genutzte Bibliotheken tauglich machen

en: When possible do not generate stack frames
de: Wenn möglich, keine Stapelrahmen erzeugen

en: When running CSE, follow jumps to their targets
de: Beim Durchlaufen von CSE: Sprüngen zu ihren Zielen folgen

en: When set to 1, use expensive methods to eliminate all redundant constraints
de: Wenn auf 1 gesetzt, werden teure Methoden zum Beseitigen aller überflüssigen Nebenbedingungen verwendet

en: Whether to use canonical types
de: Ob kanonische Typen zu verwenden sind

en: While setting up signal handler: %m
de: Während des Setzens des Signalhandlers: %m

en: While setting up signal stack: %m
de: Während des Setzens des Signalstapels: %m

en: Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape
de: Ohne Auffüllen gibt es nicht genügend Elemente in eingebauter RESHAPE-Quelle bei %L um zur Form zu passen

en: Work around VR4130 mflo/mfhi errata
de: Errata für VR4130 mflo/mfhi beachten und umgehen

en: Work around a hardware anomaly by adding a number of NOPs before a
de: Umgehung einer Hardwarebesonderheit mit zusätzlichen NOPs vor einem

en: Work around an early 4300 hardware bug
de: Einen frühen 4300-Hardware-Bug umgehen

en: Work around bug in multiplication instruction
de: Fehler in Multiplikationsbefehl umgehen

en: Work around certain R10000 errata
de: Bestimmte R10000-Errata umgehen

en: Work around certain R4000 errata
de: Bestimmte R4000-Errata umgehen

en: Work around certain R4400 errata
de: Bestimmte R4400-Errata umgehen

en: Work around certain VR4120 errata
de: Bestimmte VR4120-Errata beachten und umgehen

en: Work around errata for early SB-1 revision 2 cores
de: Fehler früher SB-1 Revision 2 Kerne umgehen

en: Work around hardware multiply bug
de: Hardware-Multiplikationsfehler umgehen

en: Writing module %s at line %d column %d: %s
de: Modul %s in Zeile %d, Spalte %d wird geschrieben: %s

en: XXX entering pop_everything ()
de: XXX Eintritt in pop_everything ()

en: XXX leaving pop_everything ()
de: XXX pop_everything () wird verlassen

en: Zero is not a valid statement label at %C
de: Null ist keine gültige Anweisungsmarke bei %C

en: Zero width in format descriptor
de: Breite null in Formatbeschreibung

en: [Leaving %s]
de: [%s wird verlassen]

en: [cannot find %s]
de: [%s kann nicht gefunden werden]

en: [disabled]
de: [ausgeschaltet]

en: [enabled]
de: [eingeschaltet]

en: [super ...] must appear in a method context
de: [super ...] muss in einem Methodenkontext auftreten

en: __BELOW100__ attribute not allowed with auto storage class
de: Attribut __BELOW100__ nicht mit Speicherklasse »auto« erlaubt

en: __builtin_eh_return not supported on this target
de: __builtin_eh_return für dieses Ziel nicht unterstützt

en: __builtin_rx_%s takes 'C', 'Z', 'S', 'O', 'I', or 'U'
de: __builtin_rx_%s benötigt 'C', 'Z', 'S', 'O', 'I' oder 'U'

en: __builtin_saveregs not supported by this subtarget
de: __builtin_saveregs wird für dieses Teilziel nicht unterstützt

en: __builtin_saveregs not supported by this target
de: __builtin_saveregs wird von diesem Ziel nicht unterstützt

en: __io address 0x%x is the same for %qE and %qE
de: __io-Adresse 0x%x ist die selbe für %qE und %qE

en: __io vars are volatile by default
de: __io-Variablen sind standardmäßig »volatile«

en: __label__ declarations are only allowed in function scopes
de: __label__-Deklarationen sind nur im Funktionsgültigkeitsbereich erlaubt

en: `
de: »

en: a brace-enclosed initializer is not allowed here
de: eine geschweift geklammerte Initialisierung ist hier nicht erlaubt

en: a call to a constructor cannot appear in a constant-expression
de: ein Konstruktoraufruf kann nicht in einem Konstanten-Ausdruck auftreten

en: a call to thunk improperly represented in the call graph:
de: ein Aufruf von Thunk ist im Aufrufgraphen falsch repräsentiert:

en: a cast to a type other than an integral or enumeration type cannot appear in a constant-expression
de: Eine Typumwandlung, die weder zu ganzzahligen noch Aufzählungstypen führt, kann nicht in einem Konstantenausdruck auftreten

en: a class-key must be used when declaring a friend
de: ein Klassenschlüssel muss bei Deklaration als »friend« verwendet werden

en: a comma operator cannot appear in a constant-expression
de: ein Komma-Operator kann nicht in einem Konstanten-Ausdruck auftreten

en: a destructor cannot be %<constexpr%>
de: Destruktor kann nicht %<constexpr%> sein

en: a function call cannot appear in a constant-expression
de: ein Funktionsaufruf kann nicht in einem Konstanten-Ausdruck auftreten

en: a function-definition is not allowed here
de: eine Funktionsdefinition ist hier nicht erlaubt

en: a label can only be part of a statement and a declaration is not a statement
de: eine Marke kann nur Teil einer Anweisung sein, und eine Deklaration ist keine Anweisung

en: a lambda closure type has a deleted copy assignment operator
de: Lambda-Abschlusstyp hat gelöschten Kopier-Zuweisungsoperator

en: a lambda closure type has a deleted default constructor
de: Lambda-Abschlusstyp hat gelöschten Standardkonstruktor

en: a member of a structure or union cannot have a variably modified type
de: Ein Element einer Struktur oder Union kann nicht variabel modifizierten Typ haben

en: a parameter cannot be declared %<constexpr%>
de: ein Parameter kann nicht als %<constexpr%> deklariert sein

en: a parameter list with an ellipsis can%'t match an empty parameter name list declaration
de: Eine Parameterliste mit Auslassung passt nicht zu einer leeren Parameternamenslistendeklaration

en: a storage class can only be specified for objects and functions
de: eine Speicherklasse kann nur für Objekte und Funktionen angegeben werden

en: a template cannot be defaulted
de: ein Template kann nicht vorbelegt werden

en: a template declaration cannot appear at block scope
de: eine Template-Deklaration kann nicht im Block-Gültigkeitsbereich auftreten

en: a template-id may not appear in a using-declaration
de: eine Template-ID darf nicht in »using«-Deklaration auftreten

en: a using-declaration cannot specify a template-id.  Try %<using %D%>
de: eine %<using%>-Deklaration kann keine Template-ID angeben. Stattdessen %<using %D%> versuchen

en: a wide string is invalid in this context
de: eine Wide-Zeichenkette ist in diesem Kontext ungültig

en: abnormal edges for no purpose in bb %i
de: abnormale Kanten ohne Zweck in bb %i

en: abort in %s, at %s:%d
de: Abbruch in %s, bei %s:%d

en: abstract declarator %qT used as declaration
de: abstrakter Deklarator %qT als Deklaration verwendet

en: accessing %qD member instead of initialized %qD member in constant expression
de: Zugriff auf Element %qD statt auf initialisiertes Element %qD in Konstantenausdruck

en: accessing value of %qE through a %qT glvalue in a constant expression
de: auf Wert von %qE wird über ein %qT GL-Wert in Konstantenausdruck zugegriffen

en: accumulator is not a constant integer
de: Akkumulator ist keine Ganzzahlkonstante

en: accumulator number is out of bounds
de: Akkumulatorzahl außerhalb der Grenzen

en: actual argument to INTENT = OUT/INOUT
de: effektives Argument für INTENT = OUT/INOUT

en: address area attribute cannot be specified for functions
de: Adressbereichsattribut kann nicht für Funktionen angegeben werden

en: address area of %q+D conflicts with previous declaration
de: Adressbereich von %q+D in Konflikt mit vorheriger Deklaration

en: address of explicit register variable %qD requested
de: Adresse der Register-Variablen %qD angefordert

en: address of global register variable %qD requested
de: Adresse der globalen Variablen %qD angefordert

en: address of local variable %q+D returned
de: Adresse der lokalen Variable %q+D zurückgegeben

en: address of overloaded function with no contextual type information
de: Adresse einer überladenen Funktion ohne Typinformationen aus Kontext

en: address of register variable %qD requested
de: Adresse der Register-Variablen %qD angefordert

en: address offset not a constant
de: Adressversatz ist keine Konstante

en: address operand requires constraint for X, Y, or Z register
de: Adressoperand erfordert Beschränkung für X-, Y- oder Z-Register

en: address region attributes not allowed with auto storage class
de: Attribute für Adressregion sind mit Speicherklasse »auto« nicht erlaubt

en: address region attributes on pointed-to types ignored
de: Attribute für Adressregion an Typen, auf die gezeigt wird, ignoriert

en: address requested for %qD, which is declared %<register%>
de: Adresse für %qD angefordert, was als %<register%> deklariert ist

en: address taken, but ADDRESSABLE bit not set
de: Adresse genommen, aber ADDRESSABLE-Bit nicht gesetzt

en: address-of an object %qE with thread local or automatic storage is not a constant expression
de: Adresse eines Objektes %qE mit thread-lokalem oder automatischem Speicher ist kein konstanter Ausdruck

en: after previous declaration %q+D
de: nach vorheriger Deklaration %q+D

en: after previous specification in %q+#D
de: nach vorheriger Spezifikation in %q+#D

en: aggregate %q#D has incomplete type and cannot be defined
de: Aggregat %q#D hat unvollständigen Typ und kann nicht definiert werden

en: aggregate value used where a complex was expected
de: zusammengesetzer Wert verwendet, wo »complex« erwartet wurde

en: aggregate value used where a fixed-point was expected
de: zusammengesetzten Wert verwendet, wo Festkomma erwartet wurde

en: aggregate value used where a float was expected
de: zusammengesetzten Wert verwendet, wo Gleitkomma erwartet wurde

en: aggregate value used where an integer was expected
de: zusammengesetzter Wert verwendet, wo Ganzzahl erwartet wurde

en: alias definitions not supported in Mach-O; ignored
de: Alias-Definitionen werden nicht in Mach-O unterstützt; ignoriert

en: alias definitions not supported in this configuration
de: Alias-Definitionen werden in dieser Konfiguration nicht unterstützt

en: alignment (%u) for %s exceeds maximum alignment for global common data.  Using %u
de: Ausrichtung (%u) für %s überschreitet maximale Ausrichtung für gobale gemeinsame Daten. Es wird %u verwendet

en: alignment for %q+D must be at least %d
de: Ausrichtung für %q+D muss mindestens %d sein

en: alignment for %q+D was previously specified as %d and may not be decreased
de: Ausrichtung für %q+D wurde zuvor als %d angegeben und kann nicht verringert werden

en: alignment may not be specified for %q+D
de: Für %q+D darf keine Ausrichtung angegeben werden

en: alignment must be a small power of two, not %d
de: Ausrichtung muss eine kleine Zweierpotenz sein, nicht %d

en: alignment of %q+D is greater than maximum object file alignment.  Using %d
de: Ausrichtung von %q+D ist größer als maximale Objektdateiausrichtung. %d verwendet

en: alignment of %qD is bigger than original declaration
de: Ausrichtung von %qD ist größer als ursprüngliche Deklaration

en: alignment of array elements is greater than element size
de: Ausrichtung der Feldelemente ist größer als Elementgröße

en: all member functions in class %qT are private
de: alle Elementfunktionen in Klasse %qT sind privat

en: alloc_size parameter outside range
de: Parameter alloc_size außerhalb des Wertebereiches

en: already captured %<this%> in lambda expression
de: %<this%> bereits in Lambda-Ausdruck aufgefangen

en: also found %<%c%s%>
de: auch %<%c%s%> gefunden

en: ambiguates built-in declaration %q#D
de: macht eingebaute Deklaration %q#D mehrdeutig

en: ambiguates old declaration %q+#D
de: macht alte Deklaration %q+#D mehrdeutig

en: ambiguous class template instantiation for %q#T
de: mehrdeutige Klassentemplate-Instanziierung für %q#T

en: ambiguous conversion for array subscript
de: mehrdeutige Umwandlung für Feldindex

en: ambiguous default type conversion from %qT
de: mehrdeutige Standard-Typumwandlung von %qT

en: ambiguous method %s%s%s
de: mehrdeutige Methode %s%s%s

en: ambiguous overload for %<operator%s%> in %<%E %s %E%>
de: mehrdeutiges Überladen für %<operator%s%> in %<%E %s %E%>

en: ambiguous overload for %<operator%s%> in %<%E%s%>
de: mehrdeutiges Überladen für %<operator%s%> in %<%E%s%>

en: ambiguous overload for %<operator%s%> in %<%s%E%>
de: mehrdeutiges Überladen für %<operator%s%> in %<%s%E%>

en: ambiguous overload for %<operator[]%> in %<%E[%E]%>
de: mehrdeutiges Überladen für %<operator[]%> in %<%E[%E]%>

en: ambiguous overload for %qs in %<%s %E%>
de: mehrdeutiges Überladen für %qs in %<%s %E%>

en: ambiguous overload for ternary %<operator?:%> in %<%E ? %E : %E%>
de: mehrdeutiges Überladen für ternären %<operator?:%> in %<%E ? %E : %E%>

en: ambiguous template specialization %qD for %q+D
de: mehrdeutige Templatespezialisierung %qD für %q+D

en: an address area attribute cannot be specified for local variables
de: für lokale Variablen kann kein Adressbereichsattribut angegeben werden

en: an anonymous struct cannot have function members
de: eine anonyme struct kann keine Funktionselemente haben

en: an anonymous union cannot have function members
de: eine anonyme Union kann keine Funktionselemente haben

en: an argument type that has a default promotion can%'t match an empty parameter name list declaration
de: Ein Argumenttyp mit Standard-Promotion passt nicht zu leerer Parameternamenslistendeklaration

en: an array reference cannot appear in a constant-expression
de: eine Feldreferenz kann nicht in einem Konstanten-Ausdruck auftreten

en: an asm-specification is not allowed on a function-definition
de: asm-Spezifikation ist bei Funktionsdefinition nicht erlaubt

en: an assignment cannot appear in a constant-expression
de: eine Zuweisung kann nicht in einem Konstanten-Ausdruck auftreten

en: an decrement cannot appear in a constant-expression
de: eine Verringerung kann nicht in einem Konstanten-Ausdruck auftreten

en: an explicit specialization must be preceded by %<template <>%>
de: einer expliziten Spezialisierung muss %<template <>%> vorausgehen

en: an increment cannot appear in a constant-expression
de: eine Erhöhung kann nicht in einem Konstanten-Ausdruck auftreten

en: an indirect edge from %s has no corresponding call_stmt
de: eine indirekte Kante von %s hat kein passendes call_stmt

en: an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:
de: eine indirekte Kante mit unbekanntem Aufrufziel korrespondiert mit einem call_stmt mit einer unbekannten Deklaration:

en: anachronism:
de: Anachronismus:

en: anachronistic old-style base class initializer
de: anachronistische Basisklasseninitialisierung im alten Stil

en: and %qT has no template constructors
de: und %qT hat keinen Template-Konstruktor

en: anonymous %s declared inside parameter list
de: anonymes %s innerhalb Parameterliste deklariert

en: anonymous struct not inside named type
de: anonymes struct nicht innerhalb eines benannten Typs

en: anonymous type with no linkage used to declare variable %q#D with linkage
de: anonymer Typ ohne Bindung verwendet, um Variable %q#D mit Bindung zu deklarieren

en: anonymous union with no members
de: anonyme Union ohne Element

en: applying #pragma weak %q+D after first use results in unspecified behavior
de: Anwendung von #pragma weak %q+D nach erster Benutzung führt zu nicht spezifiziertem Verhalten

en: args to be formatted is not %<...%>
de: zu formatierendes Argument ist nicht %<...%>

en: argument %d of %qE might be a candidate for a format attribute
de: Argument %d von %qE könnte Kandidat für Formatattribut sein

en: argument %d of %qE must be a multiple of %d
de: Argument %d von %qE muss ein Vielfaches von %d sein

en: argument %d of %qE must be an address
de: Argument %d von %qE muss eine Adresse sein

en: argument %d of %qE must be in the range %d...%d
de: Argument %d von %qE muss im Bereich %d...%d liegen

en: argument %q+D might be clobbered by %<longjmp%> or %<vfork%>
de: Argument %q+D könnte von »longjmp« oder »vfork« zerstört werden

en: argument %qD doesn%'t match built-in prototype
de: Argument %qD passt nicht zu eingebautem Prototypen

en: argument %qD doesn%'t match prototype
de: Argument %qD passt nicht zum Prototypen

en: argument %qd is not a constant
de: Argument %qd ist keine Konstante

en: argument %qs to %<-Wnormalized%> not recognized
de: Argument %qs für  %<-Wnormalized%> nicht erkannt

en: argument %qs to %<-femit-struct-debug-detailed%> not recognized
de: Argument %qs für  %<-femit-struct-debug-detailed%> nicht erkannt

en: argument %qs to %<-femit-struct-debug-detailed%> unknown
de: Argument %qs für %<-femit-struct-debug-detailed%> unbekannt

en: argument 1 must be a 5-bit signed literal
de: Argument 1 muss ein vorzeichenbehaftetes 5-Bit-Symbol sein

en: argument 1 of __builtin_altivec_predicate is out of range
de: Argument 1 von __builtin_altivec_predicate ist außerhalb des Wertebereiches

en: argument 1 of __builtin_altivec_predicate must be a constant
de: Argument 1 von __builtin_altivec_predicate muss eine Konstante sein

en: argument 1 of __builtin_paired_predicate is out of range
de: Argument 1 von __builtin_paired_predicate ist außerhalb des Wertebereiches

en: argument 1 of __builtin_paired_predicate must be a constant
de: Argument 1 von __builtin_paired_predicate muss eine Konstante sein

en: argument 1 of __builtin_spe_predicate is out of range
de: Argument 1 von __builtin_spe_predicate ist außerhalb des Wertebereiches

en: argument 1 of __builtin_spe_predicate must be a constant
de: Argument 1 von __builtin_spe_predicate muss eine Konstante sein

en: argument 2 must be a 5-bit unsigned literal
de: Argument 2 muss ein vorzeichenloses 5-Bit-Symbol sein

en: argument 3 must be a 1-bit unsigned literal
de: Argument 3 muss ein vorzeichenloses 1-Bit-Symbol sein

en: argument 3 must be a 2-bit unsigned literal
de: Argument 3 muss ein vorzeichenloses 2-Bit-Symbol sein

en: argument 3 must be a 4-bit unsigned literal
de: Argument 3 muss ein vorzeichenloses 4-Bit-Symbol sein

en: argument dependent lookup finds %q+D
de: Argumentabhängiges Nachschlagen findet %q+D

en: argument in position %qP is not a potential constant expression
de: Argument in Position %qP ist kein potentieller konstanter Ausdruck

en: argument must be a constant
de: Argument muss eine Konstante sein

en: argument must be a field reference
de: Argument muss eine Feldreferenz sein

en: argument must be array or slice or channel
de: Argument muss Feld oder Scheibe oder Kanal sein

en: argument must be channel
de: Argument muss ein Kanal sein

en: argument must be string or array or slice or map or channel
de: Argument muss Zeichenkette oder Feld oder Scheibe oder Abbildung oder Kanal sein

en: argument must have complex type
de: Argument muss komplexen Typen haben

en: argument of %<__builtin_eh_return_regno%> must be constant
de: Argument für »__builtin_eh_return_regno« muss konstant sein

en: argument of %qE attribute is not "ilink1" or "ilink2"
de: Argument des Attributes %qE ist nicht "ilink1" oder "ilink2"

en: argument of %qE attribute is not a string constant
de: Argument des Attributes %qE ist keine Zeichenkettenkonstante

en: argument of function call might be a candidate for a format attribute
de: Argument des Funktionsaufrufs könnte Kandidat für Formatattribut sein

en: argument of type %qT does not match %qT
de: Argument des Typs %qT passt nicht zu %qT

en: argument to %%:compare-debug-auxbase-opt does not end in .gk
de: Argument für %%:compare-debug-auxbase-opt endet nicht mit .pk

en: argument to %qE attribute is neither zero, nor one
de: Argument des Attributes %qE ist weder Null noch Eins

en: argument to %qE attribute larger than %d
de: Argument für Attribut %qE ist größer als %d

en: argument to %qs must be a 2-bit unsigned literal
de: Argument für %qs muss ein vorzeichenloses 2-Bit-Symbol sein

en: argument to %qs should be a non-negative integer
de: Argument von %qs sollte eine nicht-negative Ganzzahl sein

en: argument to decltype must be an expression
de: Argument für decltype muss ein Ausdruck sein

en: argument to dss must be a 2-bit unsigned literal
de: Argument für dss muss ein vorzeichenloses 2-Bit-Symbol sein

en: arguments '%s' and '%s' for intrinsic %s
de: Argumente »%s« und »%s« für intrinsisches %s

en: arguments '%s' and '%s' for intrinsic '%s'
de: Argumente »%s« und »%s« für intrinsisches »%s«

en: arguments 'a%d' and 'a%d' for intrinsic '%s'
de: Argumente »a%d« und »a%d« für intrinsisches »%s«

en: arguments 1 and 2 have different types
de: Argumente 1 und 2 haben verschiedene Typen

en: arguments to destructor are not allowed
de: Argumente für Destruktor sind nicht erlaubt

en: arithmetic IF
de: arithmetisches IF

en: arithmetic on pointer to an incomplete type
de: Arithmetik mit Zeiger auf unvollständigen Typen

en: array %q+D assumed to have one element
de: Feld %q+D als einelementig betrachtet

en: array %qD initialized by parenthesized string literal %qE
de: Feld %qD mit geklammerter Zeichenkettenkonstante %qE initialisiert

en: array assignment
de: Feld-Zuweisung

en: array bound forbidden after parenthesized type-id
de: Feldgrenze hinter geklammerter type-id ist verboten

en: array bound is not an integer constant
de: Feldgrenze ist keine Ganzzahlkonstante

en: array index in initializer exceeds array bounds
de: Feldindex in Initialisierung überschreitet Feldgrenzen

en: array index in initializer is not an integer constant expression
de: Feldindex in Initialisierung ist kein konstanter Ganzzahlausdruck

en: array index in initializer not of integer type
de: Feldindex in Initialisierung hat nicht Ganzzahltyp

en: array index in non-array initializer
de: Feldindex in Nicht-Feld-Initialisierung

en: array index range in initializer exceeds array bounds
de: Feldindexbereich in Initialisierung überschreitet Feldgrenzen

en: array initialized from non-constant array expression
de: Feld mit nicht konstantem Feldausdruck initialisiert

en: array initialized from parenthesized string constant
de: Feld mit geklammerter Zeichenkettenkonstante initialisiert

en: array is not addressable
de: Feld ist nicht adressierbar

en: array must be initialized with a brace-enclosed initializer
de: Feld muss mit Initialisierung mit umgebenden geschweiften Klammern initialisiert werden

en: array of inappropriate type initialized from string constant
de: Feld unpassenden Typs mit Zeichenkettenkonstante initialisiert

en: array size missing in %q+D
de: Feldgröße fehlt in %q+D

en: array size missing in %qD
de: Feldgröße fehlt in %qD

en: array subscript has type %<char%>
de: Feldindex hat Typ %<char%>

en: array subscript is above array bounds
de: Feldindex ist oberhalb der Feldgrenzen

en: array subscript is below array bounds
de: Feldindex ist unterhalb der Feldgrenzen

en: array subscript is not an integer
de: Feldindex ist keine Ganzzahl

en: array subscript is outside array bounds
de: Feldindex ist außerhalb der Feldgrenzen

en: array subscript out of bound
de: Feldindex ist außerhalb der Feldgrenzen

en: array type has incomplete element type
de: Feldtyp hat unvollständigen Elementtypen

en: array used as initializer
de: Feld als Initialisierung verwendet

en: arrays of functions are not meaningful
de: Felder von Funktionen sind sinnlos

en: as %qD
de: als %qD

en: asm clobber conflict with input operand
de: asm-Konflikt mit Eingabeoperand

en: asm clobber conflict with output operand
de: asm-Konflikt mit Ausgabeoperand

en: asm declaration ignored due to conflict with previous rename
de: asm-Deklaration wegen Konflikt mit vorheriger Umbenennung ignoriert

en: asm operand %d probably doesn%'t match constraints
de: asm-Operand %d passt wahrscheinlich nicht zu den Bedingungen

en: asm-specifier for variable %qE conflicts with asm clobber list
de: asm-Spezifizierer für Variable %qE steht in Konflikt mit asm-Konflikt-Liste

en: assert: %s is assign compatible with %s
de: assert: %s ist mit %s zuweisungsverträglich

en: assertion missing after %qs
de: Behauptung fehlt hinter %qs

en: assigning to an array from an initializer list
de: Zuweisung an Feld von Initialisierungsliste

en: assignment
de: Zuweisung

en: assignment (not initialization) in declaration
de: Zuweisung (nicht Initialisierung) in Deklaration

en: assignment discards %qv qualifier from pointer target type
de: Zuweisung streicht Qualifizierer %qv von Zeiger-Zieltyp

en: assignment from distinct Objective-C type
de: Zuweisung von anderem Objective-C-Typ

en: assignment from incompatible pointer type
de: Zuweisung von inkompatiblem Zeigertyp

en: assignment from pointer to non-enclosed address space
de: Zuweisung von Zeiger auf nicht eingeschlossenen Adressbereich

en: assignment left-hand side might be a candidate for a format attribute
de: Links-Zuweisung könnte Kandidat für Formatattribut sein

en: assignment makes %q#v qualified function pointer from unqualified
de: Zuweisung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: assignment makes integer from pointer without a cast
de: Zuweisung erzeugt Ganzzahl von Zeiger ohne Typkonvertierung

en: assignment makes pointer from integer without a cast
de: Zuweisung erzeugt Zeiger von Ganzzahl ohne Typkonvertierung

en: assignment of constant field %qD
de: Zuweisung des konstanten Feldes %qD

en: assignment of function %qD
de: Zuweisung der Funktion %qD

en: assignment of member %qD in read-only object
de: Zuweisung von Element %qD in schreibgeschütztem Objekt

en: assignment of read-only location %qE
de: Zuweisung der schreibgeschützten Speicherstelle %qE

en: assignment of read-only member %qD
de: Zuweisung des schreibgeschützten Elementes %qD

en: assignment of read-only named return value %qD
de: Zuweisung des schreibgeschützten benannten Rückgabewertes %qD

en: assignment of read-only parameter %qD
de: Zuweisung des schreibgeschützten Parameters %qD

en: assignment of read-only reference %qD
de: Zuweisung der schreibgeschützten Referenz %qD

en: assignment of read-only variable %qD
de: Zuweisung der schreibgeschützten Variable %qD

en: assignment suppression
de: Zuweisungsunterdrückung

en: assuming cast to type %qT from overloaded function
de: Umwandlung in Typ %qT von überladener Funktion wird angenommen

en: assuming pointer to member %qD
de: Zeiger auf Element %qD wird angenommen

en: assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C1 +- C2
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn »X +- C1 cmp C2« in »X cmp C1 +- C2« geändert wird

en: assuming signed overflow does not occur when combining constants around a comparison
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Konstanten um einen Vergleich kombiniert werden

en: assuming signed overflow does not occur when negating a division
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Division negiert wird

en: assuming signed overflow does not occur when reducing constant in comparison
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Konstante in Vergleich verringert wird

en: assuming signed overflow does not occur when simplifying %</%> or %<%%%> to %<>>%> or %<&%>
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn %</%> oder %<%%%> auf %<>>%> oder %<&%> vereinfacht wird

en: assuming signed overflow does not occur when simplifying %<abs (X)%> to %<X%> or %<-X%>
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn %<abs (X)%> auf %<X%> oder %<-X%> vereinfacht wird

en: assuming signed overflow does not occur when simplifying && or || to & or |
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn && oder || zu & oder | vereinfacht wird

en: assuming signed overflow does not occur when simplifying ==, != or ! to identity or ^
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn ==, != oder ! zu Identität oder ^ vereinfacht wird

en: assuming signed overflow does not occur when simplifying conditional
de: Annahme, dass vorzeichenbehafteter Überlauf bei Vereinfachung der Bedingung nicht auftritt

en: assuming signed overflow does not occur when simplifying conditional to constant
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Bedingung zu Konstante vereinfacht wird

en: assuming signed overflow does not occur when simplifying range test
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Bereichsprüfung vereinfacht wird

en: assuming that the loop counter does not overflow
de: es wird angenommen, dass die Schleifen-Zählvariable nicht überläuft

en: assuming that the loop is not infinite
de: es wird angenommen, dass es sich nicht um eine Endlosschleife handelt

en: atexit failed
de: atexit gescheitert

en: attempt to take address of bit-field structure member %qD
de: Versuch, die Adresse des Bitfeldstrukturelements %qD zu ermitteln

en: attribute %qE argument not a string
de: Attributargument von %qE ist keine Zeichenkette

en: attribute %qs applies to array types only
de: Attribut %qs bezieht sich nur auf Feldtypen

en: attribute declaration
de: Attribut-Deklaration

en: attribute for %q+#T must follow the %qs keyword
de: Attribut für %q+#T muss dem Schlüsselwort %qs folgen

en: attribute ignored in declaration of %q+#T
de: Attribut in Deklaration von %q+#T ignoriert

en: attribute interrupt_handler is not compatible with -m5-compact
de: Attribut interrupt_handler ist mit -m5-compact unverträglich

en: attribute(target("%s")) is unknown
de: attribute(target("%s")) ist unbekannt

en: attributes after parenthesized initializer ignored
de: Attribute hinter geklammerter Initialisierung werden ignoriert

en: attributes are not allowed on a function-definition
de: bei einer Funktionsdefinition sind keine Attribute erlaubt

en: attributes ignored on elaborated-type-specifier that is not a forward declaration
de: Attribute an Spezifizierer ausführlichen Typs ignoriert, der keine Vorwärtsdeklaration ist

en: attributes ignored on template instantiation
de: Attribute an Templateinstanziierung ignoriert

en: attributes ignored on uninstantiated type
de: Attribute an instanziiertem Typen ignoriert

en: attributes in parameter array declarator ignored
de: Attribute in Parameterfelddeklarator ignoriert

en: attributes may not be specified before the %<@%D%> Objective-C++ keyword
de: Attribute dürfen nicht vor dem Objective-C++-Schlüsselwort %<@%D%> angegeben werden

en: automatic variable %qE cannot be %<threadprivate%>
de: automatische Variable %qE kann nicht %<threadprivate%> sein

en: aux field set for edge %s->%s
de: Aux-Feld für Kante %s->%s gesetzt

en: aux field set for indirect edge from %s
de: Aux-Feld für indirekte Kante %s von gesetzt

en: backend decl for module variable %s already exists
de: Backend-Deklaration für Modulvariable %s ist bereits vorhanden

en: bad PC range for debug info for local %q+D
de: schlechter PC-Bereich für Debuginfo für lokales %q+D

en: bad address
de: Falsche Adresse

en: bad address, not (reg+disp):
de: Falsche Adresse, nicht (reg+disp):

en: bad address, not a constant):
de: falsche Adresse, keine Konstante):

en: bad address, not post_inc or pre_dec:
de: Falsche Adresse, nicht post_inc oder pre_dec:

en: bad amount of stack space removal: %d
de: Falscher Betrag der Stapelspeicherentfernung: %d

en: bad array initializer
de: schlechte Feldinitialisierung

en: bad builtin code
de: Falscher eingebauter Code

en: bad builtin fcode
de: Falscher eingebauter fcode

en: bad condition code
de: Falscher Bedingungscode

en: bad expression type during walk (%d)
de: Falscher Ausdruckstyp beim Durchlaufen (%d)

en: bad format of .zip/.jar archive
de: falsches Format des .zip/.jar-Archives

en: bad insn for 'A'
de: falscher Befehl für 'A'

en: bad insn in frv_print_operand, 0 case
de: Falscher Befehl in frv_print_operand, Fall 0:

en: bad insn in frv_print_operand, bad const_double
de: Falscher Befehl in frv_print_operand, falsches const_double

en: bad insn in frv_print_operand, z case
de: Falscher Befehl in frv_print_operand, Fall »z«:

en: bad insn to frv_print_operand, 'F' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »F«:

en: bad insn to frv_print_operand, 'L' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »L«:

en: bad insn to frv_print_operand, 'M/N' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »M/N«:

en: bad insn to frv_print_operand, 'O' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »O«:

en: bad insn to frv_print_operand, 'e' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »e«:

en: bad insn to frv_print_operand, 'f' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »f«:

en: bad insn to frv_print_operand, 'g' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »g«:

en: bad insn to frv_print_operand, P modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »P«:

en: bad insn to frv_print_operand_address:
de: Falscher Befehl für frv_print_operand_address:

en: bad insn to frv_print_operand_memory_reference:
de: Falscher Befehl für frv_print_operand_memory_reference:

en: bad method signature
de: Schlechte Methodensignatur

en: bad move
de: ungültige Bewegung

en: bad operand
de: Ungültiger Operand

en: bad option %s to optimize attribute
de: schlechte Option %s für Attribut »optimize«

en: bad option %s to pragma attribute
de: schlechte Option %s für Attribut »pragma«

en: bad output_condmove_single operand
de: Falscher Operand für output_condmove_single

en: bad output_move_double operand
de: Falscher Operand für output_move_double

en: bad output_move_single operand
de: Falscher Operand für output_move_single

en: bad pc in exception_table
de: schlechtes PC in execution_table

en: bad register
de: falsches Register

en: bad register to frv_print_operand_memory_reference_reg:
de: Falsches Register für frv_print_operand_memory_reference_reg:

en: bad shift insn:
de: Falscher Schiebe-Befehl:

en: bad string constant
de: Schlechte Zeichenkettenkonstante

en: bad test
de: Falscher Test

en: bad type in parameter debug info
de: schlechter Typ in Parameter-Debug-Info

en: bad value %<%s%> for -mtls-size= switch
de: Falscher Wert %<%s%> für Schalter -mtls-size=

en: bad value %<%s%> for -mtune= switch
de: Falscher Wert %<%s%> für Schalter -mtune=

en: bad value %qs for -mcpu switch
de: Falscher Wert %qs für Schalter -mcpu

en: bad value %qs for -mfp-rounding-mode switch
de: Falscher Wert %qs für Schalter -mfp-rounding-mode

en: bad value %qs for -mfp-trap-mode switch
de: Falscher Wert %qs für Schalter -mfp-trap-mode

en: bad value %qs for -mmemory-latency
de: Falscher Wert %qs für -mmemory-latency

en: bad value %qs for -mtls-size switch
de: Falscher Wert %qs für Schalter -mtls-size

en: bad value %qs for -mtrap-precision switch
de: falscher Wert %qs für Schalter -mtrap-precision

en: bad value %qs for -mtune switch
de: Falscher Wert %qs für Schalter -mtune

en: bad value (%s) for %s switch
de: Falscher Wert (%s) für Schalter %s

en: bad value (%s) for %sarch=%s %s
de: falscher Wert (%s) für %sarch=%s %s

en: bad value (%s) for %sasm=%s %s
de: falscher Wert (%s) für %sasm=%s %s

en: bad value (%s) for %scmodel=%s %s
de: falscher Wert (%s) für %scmodel=%s %s

en: bad value (%s) for %sfpmath=%s %s
de: Falscher Wert (%s) für %sfpmath=%s %s

en: bad value (%s) for %sstringop-strategy=%s %s
de: falscher Wert (%s) für Schalter %sstringop-strategy=%s %s

en: bad value (%s) for %stls-dialect=%s %s
de: falscher Wert (%s) für %stls-dialect=%s %s

en: bad value (%s) for %stune=%s %s
de: Falscher Wert (%s) für %stune=%s %s

en: bad value (%s) for -march= switch
de: falscher Wert (%s) für Schalter -march=

en: bad value (%s) for -mcmodel= switch
de: Falscher Wert (%s) für Schalter -mcmodel=

en: bad value (%s) for -mcpu
de: falscher Wert (%s) für -mcpu

en: bad value (%s) for -mtune
de: falscher Wert (%s) für -mtune

en: bad value (%s) for -mtune= switch
de: falscher Wert (%s) für Schalter -mtune=

en: bad value constant type %d, index %d
de: Schlechter Wertekonstantentyp %d, Index %d

en: bad value for -mcall-%s
de: Falscher Wert für -mcall-%s

en: bad value for -msdata=%s
de: Falscher Wert für -msdata=%s

en: bad zip/jar file %s
de: schlechte ZIP/JAR-Datei %s

en: badly nested C headers from preprocessor
de: schlecht geschachtelte C-Header vom Präprozessor

en: barrier region may not be closely nested inside of work-sharing, critical, ordered, master or explicit task region
de: Sperrregion darf nicht in arbeitsteilender, kritischer, geordneter, Master- oder »explicit task«-Region eng geschachtelt sein

en: base %qT will be initialized after
de: Basis %qT wird initialisiert nach

en: base class %q#T has a non-virtual destructor
de: Basisklasse %q#T hat einen nicht-virtuellen Destruktor

en: base class %q#T should be explicitly initialized in the copy constructor
de: Basisklasse %q#T sollte explizit im Kopierkonstruktor initialisiert werden

en: base class %qT has cv qualifiers
de: Basisklasse %qT hat CV-Kennzeichner

en: base initializer expansion %<%T%> contains no parameter packs
de: Auflösung der Basisinitialisierung %<%T%> enthält keine Parameterpacks

en: base operand of %<->%> has non-pointer type %qT
de: Basisoperand von %<->%> hat Nicht-Zeiger-Typ %qT

en: base operand of %<->%> is not a pointer
de: Basisoperand von %<->%> ist kein Zeiger

en: base type %qT fails to be a struct or class type
de: Basistyp %qT ist kein struct- oder Klassentyp

en: basic block %d pred edge is corrupted
de: Vorgänger des Basis-Blocks %d ist beschädigt

en: basic block %d should be marked irreducible
de: Basisblock %d sollte als irreduzibel markiert werden

en: basic block %d should not be marked irreducible
de: Basisblock %d sollte nicht als irreduzibel markiert werden

en: basic block %i edge lists are corrupted
de: Kantenlisten des Basis-Blockes %i sind beschädigt

en: basic blocks not laid down consecutively
de: Basis-Blöcke sind nicht fortlaufend

en: bb %d do not belong to loop %d
de: BB %d gehört nicht zur Schleife %d

en: bb %d on wrong place
de: bb %d an falscher Stelle

en: bit-field %q+#D with non-integral type
de: Bit-Feld %q+#D mit Nicht-Ganzzahl-Typ

en: bit-field %q+D width not an integer constant
de: Breite des Bitfeldes %q+D ist keine Ganzzahlkonstante

en: bit-field %qD with non-integral type
de: Bit-Feld %qD mit Nicht-Ganzzahl-Typ

en: bit-field %qs has invalid type
de: Bitfeld %qs hat ungültigen Typen

en: bit-field %qs width not an integer constant
de: Breite des Bitfeldes %qs ist keine Ganzzahlkonstante

en: bit-field %qs width not an integer constant expression
de: Breite des Bitfeldes %qs ist kein Ganzzahlkonstantenausdruck

en: block IF
de: Block-IF

en: body of constexpr function %qD not a return-statement
de: Körper der Funktion %qD mit konstantem Ausdruck ist keine Rückgabeanweisung

en: bogus DISPOSE construction: %d
de: nur simulierte DISPOSE-Konstruktion: %d

en: bogus JARL construction: %d
de: falsche JARL-Konstruktion: %d

en: bogus JR construction: %d
de: nur simulierte JR-Konstruktion: %d

en: bogus PREPEARE construction: %d
de: nur simulierte PREPARE-Konstruktion: %d

en: boolean registers required for the floating-point option
de: Boolsche Register für die Gleitkommaoption benötigt

en: both %<const%> and %<constexpr%> cannot be used here
de: %<const%> und %<constexpr%> können hier nicht zusammen verwendet werden

en: both %<volatile%> and %<constexpr%> cannot be used here
de:  %<volatile%> und %<constexpr%> können hier nicht zusammen verwendet werden

en: both arguments to %<__builtin___clear_cache%> must be pointers
de: beide Argumente für %<__builtin___clear_cache%> müssen Zeiger sein

en: braced spec %qs is invalid at %qc
de: geschweift geklammerte Spezifikation %qs ist bei %qc ungültig

en: braced spec body %qs is invalid
de: geschweift geklammerter Spezifikationskörper %qs ist ungültig

en: braced-group within expression allowed only inside a function
de: geklammerte Gruppe innerhalb eines Ausdrucks nur in einer Funktion erlaubt

en: braces around scalar initializer
de: geschweifte Klammern um Skalar-Initialisierung

en: braces around scalar initializer for type %qT
de: geschweifte Klammern um skalare Initialisierung für Typ %qT

en: branch %2d never executed
de: Zweig %2d niemals ausgeführt

en: branch %2d taken %s%s
de: Zweig %2d wurde genommen: %s%s

en: branch target register load optimization is not intended to be run twice
de: Ladeoptimierung für Zweig-Zielregister ist nicht dafür vorgesehen, mehrfach zu laufen

en: break statement not within loop or switch
de: break-Anweisung nicht innerhalb einer Schleife oder »switch«

en: break statement used with OpenMP for loop
de: break-Anweisung mit OpenMP für Schleife verwendet

en: built-in function %q+D declared as non-function
de: Eingebaute Funktion %q+D als Nicht-Funktion deklariert

en: built-in function %qD requires the %<-mconstant-cfstrings%> flag
de: eingebaute Funktion %qD erfordert das Kennzeichen %<-mconstant-cfstrings%>

en: built-in function %qD takes one argument only
de: eingebaute Funktion %qD nimmt nur ein Argument

en: built-in function %qE not supported for MIPS16
de: eingebaute Funktion %qE nicht für MIPS16 unterstützt

en: but %q+D does not throw; perhaps it should be declared %<noexcept%>
de: aber %q+D wird nicht geworfen; vielleicht sollte es als %<noexcept%> deklariert werden

en: but not here
de: aber nicht hier

en: bytecode stream generated with LTO version %d.%d instead of the expected %d.%d
de: Bytecode-Ströme mit LTO-Version %d.%d statt des erwarteten %d.%d erzeugt

en: bytecode stream: expected tag %s instead of %s
de: Bytecode-Strom: Marke %s statt %s erwartet

en: bytecode stream: found non-null terminated string
de: Bytecode-Strom: Nicht nullterminierte Zeichenkette gefunden

en: bytecode stream: string too long for the string table
de: Bytecode-Strom: Zeichenkette zu lang für Zeichenkettentabelle

en: bytecode stream: tag %s is not in the expected range [%s, %s]
de: Bytecode-Strom: Marke %s ist nicht im erwarteten Wertebereich [%s, %s]

en: bytecode stream: tried to jump backwards in the stream
de: Bytecode-Strom: Versuch, im Strom rückwärts zu springen

en: bytecode stream: trying to read %d bytes after the end of the input buffer
de: Bytecode-Strom: Versuch, %d Bytes nach Ende des Eingabepuffers zu lesen

en: bytecode stream: unexpected LTO section %s
de: Bytecode-Strom: unerwarteter LTO-Abschnitt %s

en: bytecode stream: unexpected tag %s
de: Bytecode-Strom: unerwartete Marke %s

en: bytecode stream: unknown GIMPLE statement tag %s
de: Bytecode-Strom: unbekannte GIMPLE-Anweisungsmarke %s

en: call   %2d never executed
de: Aufruf %2d niemals ausgeführt

en: call   %2d returned %s
de: Aufruf %2d gab %s zurück

en: call edges for non-call insn in bb %i
de: Ruf-Kanten für Nicht-Aufruf-Befehl im bb %i

en: call has circular dependency
de: Aufruf hat ringförmige Abhängigkeit

en: call is unlikely and code size would grow
de: Aufruf ist unwahrscheinlich und Codegröße würde wachsen

en: call of %<(%T) (%A)%> is ambiguous
de: Aufruf von %<(%T) (%A)%> ist nicht eindeutig

en: call of overloaded %<%D(%A)%> is ambiguous
de: Aufruf des überladenen %<%D(%A)%> ist nicht eindeutig

en: call of overloaded %<%s(%A)%> is ambiguous
de: Aufruf des überladenen %<%s(%A)%> ist mehrdeutig

en: call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined
de: Aufruf von Javas %<catch%> oder %<throw%> mit %<jthrowable%> ist nicht definiert

en: call to Java constructor with %qs undefined
de: Aufruf von Java-Konstruktor mit %qs ist nicht definiert

en: call to Java constructor, while %<jclass%> undefined
de: Aufruf von Java-Konstruktor, wobei %<jclass%> nicht definiert ist

en: call to function %qD which throws incomplete type %q#T
de: Aufruf der Funktion %qD, die unvollständigen Typen %q#T wirft

en: call to function which throws incomplete type %q#T
de: Aufruf einer Funktion, die unvollständigen Typen %q#T wirft

en: call to non-function %qD
de: Aufruf der Nicht-Funktion %qD

en: call-clobbered register used for global register variable
de: für Ruf vorgesehenes Register wurde für globale Registervariable verwendet

en: called from here
de: von hier aufgerufen

en: called object %qE is not a function
de: gerufenes Objekt %qE ist keine Funktion

en: caller edge count is negative
de: Rufer-Kantenzähler ist negativ

en: caller edge frequency %i does not match BB frequency %i
de: Rufer-Kantenhäufigkeit %i passt nicht zur BB-Häufigkeit %i

en: caller edge frequency is negative
de: Rufer-Kantenhäufigkeit ist negativ

en: caller edge frequency is too large
de: Rufer-Kantenhäufigkeit ist zu groß

en: calling %qD with attribute sseregparm without SSE/SSE2 enabled
de: Aufruf von %qD mit Attribut sseregparam ohne SSE/SSE2 aktiviert

en: calling %qT with attribute sseregparm without SSE/SSE2 enabled
de: Aufruf von %qT mit Attribut sseregparam ohne SSE/SSE2 aktiviert

en: calls to overloaded operators cannot appear in a constant-expression
de: Aufrufe überladener Operatoren können nicht in einem Konstanten-Ausdruck auftreten

en: can not find instance variable associated with property
de: mit Eigenschaft verbundene Instanzvariable nicht gefunden

en: can not use -mtp=cp15 with 16-bit Thumb
de: -mtp=cp15 kann nicht mit 16-Bit-Thumb verwendet werden

en: can not use an object as parameter to a method
de: ein Objekt kann nicht als Parameter für eine Methode verwendet werden

en: can only use %qE attribute on file-scope definitions of objects of class type
de: nur Attribut %qE kann für Definitionen von Objekten eines Klassentyps im Datei-Gültigkeitsbereich verwendet werden

en: can%'t apply both longcall and shortcall attributes to the same function
de: Die Attribute longcall und shortcall können nicht gleichzeitig für die gleiche Funktion verwendet werden

en: can%'t convert between vector values of different size
de: zwischen Vektorwerten verschiedener Größen kann nicht konvertiert werden

en: can%'t convert from incomplete type %qT to %qT
de: unvollständiger Typ %qT kann nicht nach %qT umgewandelt werden

en: can%'t convert value to a vector
de: Wert kann nicht in einen Vektor umgewandelt werden

en: can%'t create precompiled header %s: %m
de: der vorkompilierte Header »%s« kann nicht erzeugt werden: %m

en: can%'t create repository information file %qs
de: Repository-Informationsdatei %qs kann nicht erzeugt werden

en: can%'t define friend function %qs in a local class definition
de: friend-Funktion %qs kann nicht in einer lokalen Klassendefinition definiert werden

en: can%'t extend PCH file: %m
de: PCH-Datei kann nicht erweitert werden: %m

en: can%'t find %<class$%> in %qT
de: %<class$%> kann nicht in %qT gefunden werden

en: can%'t find a register in class %qs while reloading %<asm%>
de: in der Klasse %qs konnte während des Neuladens von %<asm%> kein Register gefunden werden

en: can%'t get position in PCH file: %m
de: Position in PCH-Datei kann nicht ermittelt werden: %m

en: can%'t initialize friend function %qs
de: friend-Funktion %qs kann nicht initialisiert werden

en: can%'t mix operands of decimal float and complex types
de: Operanden von dezimalen Gleitkomma- und komplexen Typen können nicht gemischt werden

en: can%'t mix operands of decimal float and other float types
de: Operanden von dezimalen und anderen Gleitkommatypen können nicht gemischt werden

en: can%'t mix operands of decimal float and vector types
de: Operanden von dezimalen Gleitkomma- und Vektortypen können nicht gemischt werden

en: can%'t open %s for reading: %m
de: %s kann nicht zum Lesen geöffnet werden: %m

en: can%'t open %s for writing: %m
de: %s kann nicht zum Schreiben geöffnet werden: %m

en: can%'t open %s: %m
de: %s kann nicht geöffnet werden: %m

en: can%'t read %s: %m
de: %s kann nicht gelesen werden: %m

en: can%'t read PCH file: %m
de: PCH-Datei kann nicht gelesen werden: %m

en: can%'t seek PCH file: %m
de: in PCH-Datei kann nicht positioniert werden: %m

en: can%'t seek in %s: %m
de: in %s kann nicht positioniert werden: %m

en: can%'t set %qE attribute after definition
de: Attribut %qE kann nicht nach der Definition gesetzt werden

en: can%'t set position in PCH file: %m
de: Position in PCH-Datei kann nicht gesetzt werden: %m

en: can%'t use %qs as a call-saved register
de: %qs kann nicht als ein rufgesichertes Register verwendet werden

en: can%'t use %qs as a call-used register
de: %qs kann nicht als ein rufverwendetes Register verwendet werden

en: can%'t use %qs as a fixed register
de: %qs kann nicht als ein festes Register verwendet werden

en: can%'t use multiple stack checking methods together
de: Es können nicht mehrere Stapelprüfungsmethoden gleichzeitig verwendet werden

en: can%'t write %s: %m
de: %s kann nicht geschrieben werden: %m

en: can%'t write PCH file
de: PCH-Datei kann nicht geschrieben werden

en: can%'t write PCH file: %m
de: PCH-Datei kann nicht geschrieben werden: %m

en: can%'t write padding to PCH file: %m
de: Auffüllung für PCH-Datei kann nicht geschrieben werden: %m

en: can%'t write to %s: %m
de: in %s kann nicht geschrieben werden: %m

en: can't get program status
de: Programm-Status kann nicht ermittelt werden

en: can't open input file: %s
de: Eingabedatei »%s« kann nicht geöffnet werden

en: can't open ldd output
de: ldd-Ausgabe kann nicht geöffnet werden

en: can't open nm output
de: nm-Ausgabe kann nicht geöffnet werden

en: can't use non gp relative absolute address
de: Nicht-GP-relative absolute Adresse kann nicht verwendet werden

en: candidate 1:
de: Kandidat 1:

en: candidate 2:
de: Kandidat 2:

en: candidate is: | candidates are:
de[0]: Kandidat ist:
de[1]: Kandidaten sind:

en: candidate is: %+#D
de: Kandidat ist: %+#D

en: candidates are:
de: Kandidaten sind:

en: candidates are: %+#D
de: Kandidaten sind: %+#D

en: cannot add an enumerator list to a template instantiation
de: Aufzählungsliste kann nicht zu Template-Instantiierung hinzugefügt werden

en: cannot allocate an object of abstract type %qT
de: es kann kein Objekt des abstrakten Typs %qT belegt werden

en: cannot apply %<offsetof%> to a non constant address
de: %<offsetof%> kann nicht auf nicht-konstante Adresse angewandt werden

en: cannot apply %<offsetof%> to destructor %<~%T%>
de: %<offsetof%> kann nicht auf Destruktor %<~%T%> angewandt werden

en: cannot apply %<offsetof%> to member function %qD
de: %<offsetof%> kann nicht auf Elementfunktion %qD angewandt werden

en: cannot apply %<offsetof%> to static data member %qD
de: %<offsetof%> kann nicht auf statisches Datenelement %qD angewendet werden

en: cannot apply %<offsetof%> when %<operator[]%> is overloaded
de: %<offsetof%> kann nicht angewandt werden, wenn %<operator[]%> überladen ist

en: cannot apply member pointer %qE to %qE, which is of non-class type %qT
de: Elementzeiger %qE kann nicht auf %qE angewandt werden, da letzteres vom Nicht-Klassen-Typ %qT ist

en: cannot bind %qT lvalue to %qT
de: L-Wert %qT kann nicht mit %qT verbunden werden

en: cannot bind bitfield %qE to %qT
de: das Bitfeld %qE kann nicht mit %qT verbunden werden

en: cannot bind packed field %qE to %qT
de: das gepackte Feld %qE kann nicht mit %qT verbunden werden

en: cannot bind rvalue %qE to %qT
de: der R-Wert %qE kann nicht mit %qT verbunden werden

en: cannot call constructor %<%T::%D%> directly
de: Konstruktor %<%T::%D%> kann nicht direkt aufgerufen werden

en: cannot call member function %qD without object
de: Elementfunktion %qD kann nicht ohne Objekt aufgerufen werden

en: cannot capture %qE by reference
de: %qE kann nicht per Referenz aufgefangen werden

en: cannot convert %qE from type %qT to type %qT
de: %qE kann nicht vom Typ %qT in den Typ %qT umgewandelt werden

en: cannot convert %qT to %qT
de: %qT kann nicht nach %qT umgewandelt werden

en: cannot convert %qT to %qT for argument %qP to %qD
de: %qT kann nicht nach %qT für Argument %qP nach %qD umgewandelt werden

en: cannot convert %qT to %qT in argument passing
de: %qT kann nicht nach %qT bei Argumentübergabe umgewandelt werden

en: cannot convert %qT to %qT in assignment
de: %qT kann nicht nach %qT in Zuweisung umgewandelt werden

en: cannot convert %qT to %qT in default argument
de: %qT kann nicht nach %qT im Standardargument umgewandelt werden

en: cannot convert %qT to %qT in initialization
de: %qT kann nicht nach %qT in Initialisierung umgewandelt werden

en: cannot convert %qT to %qT in return
de: %qT kann nicht nach %qT in Rückgabe umgewandelt werden

en: cannot convert from base %qT to derived type %qT via virtual base %qT
de: Es kann nicht von Basis %qT in abgeleiteten Typ %qT über virtuelle Basis %qT gewandelt werden

en: cannot convert to a pointer type
de: es kann nicht in Zeigertyp konvertiert werden

en: cannot convert type %qT to type %qT
de: Typ %qT kann nicht in den Typ %qT umgewandelt werden

en: cannot create pointer to reference member %qD
de: Zeiger auf Referenzelement %qD kann nicht erzeugt werden

en: cannot create temporary file
de: temporäre Datei konnte nicht angelegt werden

en: cannot create type information for type %qT because it involves types of variable size
de: für Typ %qT kann keine Typinformation erzeugt werden, weil dies Typen variabler Größe umfasst

en: cannot declare %<::main%> to be a template
de: %<::main%> kann nicht als Template deklariert werden

en: cannot declare %<::main%> to be inline
de: %<::main%> kann nicht inline deklariert werden

en: cannot declare %<::main%> to be static
de: %<::main%> kann nicht statisch deklariert werden

en: cannot declare %qD to be a bit-field type
de: %qD kann nicht als Bitfeldtyp deklariert werden

en: cannot declare bit-field %qD with function type
de: Bitfeld %qD kann nicht mit Funktionstyp deklariert werden

en: cannot declare field %q+D to be of abstract type %qT
de: Feld %q+D kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot declare member %<%T::%s%> within %qT
de: Element %<%T::%s%> kann nicht in %qT deklariert werden

en: cannot declare member function %qD to have static linkage
de: Elementfunktion %qD kann nicht deklariert werden, statische Bindung zu haben

en: cannot declare parameter %q+D to be of abstract type %qT
de: Parameter %q+D kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot declare pointer to %q#T
de: Zeiger auf %q#T kann nicht deklariert werden

en: cannot declare pointer to %q#T member
de: Zeiger auf Element %q#T kann nicht deklariert werden

en: cannot declare pointer to qualified function type %qT
de: Zeiger auf qualifizierten Funktionstypen %qT kann nicht deklariert werden

en: cannot declare reference to %q#T
de: Referenz auf %q#T kann nicht deklariert werden

en: cannot declare reference to %q#T, which is not a typedef or a template type argument
de: Referenz auf %q#T kann nicht deklariert werden, da letzteres weder Typedef noch Templatetyp-Argument ist

en: cannot declare reference to qualified function type %qT
de: Referenz auf qualifizierten Funktionstypen %qT kann nicht deklariert werden

en: cannot declare static function inside another function
de: statische Funktion innerhalb anderer Funktion kann nicht deklariert werden

en: cannot declare variable %q+D to be of abstract type %qT
de: Variable %q+D kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot decompose address
de: Adresse kann nicht zerlegt werden

en: cannot decrement a pointer to incomplete type %qT
de: Zeiger auf unvollständigen Typen %qT kann nicht verringert werden

en: cannot deduce lambda return type from a braced-init-list
de: Lambda-Rückgabetyp kann nicht aus Initialisierungsliste mit geschweiften Klammern hergeleitet werden

en: cannot define member function %<%T::%s%> within %<%T%>
de: Elementfunktion %<%T::%s%> innerhalb von %<%T%> kann nicht definiert werden

en: cannot define member of dependent typedef %qT
de: Element des abhängigen Typedef %qT kann nicht definiert werden

en: cannot delete a function.  Only pointer-to-objects are valid arguments to %<delete%>
de: Eine Funktion kann nicht gelöscht werden. Nur Zeiger auf Objekte sind gültige Argumente für %<delete%>

en: cannot disable built-in function %qs
de: Eingebaute Funktion %qs kann nicht abgeschaltet werden

en: cannot do z-register replacement
de: Z-Register kann nicht ausgetauscht werden

en: cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)
de: dynamic_cast %qE (des Typs %q#T) in Typ %q#T (%s) kann nicht vorgenommen werden

en: cannot expand %<%E%> into a fixed-length argument list
de: %<%E%> kann nicht in Argumentliste fester Länge aufgelöst werden

en: cannot expand %<%T%> into a fixed-length argument list
de: %<%T%> kann nicht in Argumentliste fester Länge aufgelöst werden

en: cannot expand initializer for member %<%D%>
de: Initialisierung für Element %<%D%> kann nicht aufgelöst werden

en: cannot explicitly declare member %q#D to have extern linkage
de: Element %q#D kann nicht explizit deklariert werden, externe Bindung zu haben

en: cannot find %s in plugin %s
    %s
de: %s kann nicht in Plugin %s gefunden werden
    %s

en: cannot find '%s'
de: »%s« kann nicht gefunden werden

en: cannot find 'ldd'
de: »ldd« kann nicht gefunden werden

en: cannot find 'nm'
de: »nm« kann nicht gefunden werden

en: cannot find LTO cgraph in %s
de: LTO cgraph kann nicht in %s gefunden werden

en: cannot find LTO section refs in %s
de: LTO-Abschnittsreferenzen können nicht in %s gefunden werden

en: cannot find LTO varpool in %s
de: LTO varpool kann nicht in %s gefunden werden

en: cannot find a valid counter:value pair:
de: Es kann kein gültiges Zähler:Wert-Paar gefunden werden:

en: cannot find class %qE
de: Klasse %qE kann nicht gefunden werden

en: cannot find file for class %s
de: Datei für Klasse %s kann nicht gefunden werden

en: cannot find interface declaration for %qE
de: Schnittstellendeklaration für %qE kann nicht gefunden werden

en: cannot find interface declaration for %qE, superclass of %qE
de: Schnittstellendeklaration für %qE, Basisklasse von %qE, kann nicht gefunden werden

en: cannot find protocol declaration for %qE
de: Protokolldeklaration für %qE kann nicht gefunden werden

en: cannot find reference tag for class %qE
de: Referenzmarke für Klasse %qE kann nicht gefunden werden

en: cannot handle inconsistent calls to %qs
de: inkonsistente Aufrufe von %qs können nicht behandelt werden

en: cannot increment a pointer to incomplete type %qT
de: Zeiger auf unvollständigen Typen %qT kann nicht erhöht werden

en: cannot initialize %qT from %qT
de: %qT kann nicht von %qT initialisiert werden

en: cannot initialize aggregate of type %qT with a compound literal
de: Aggregat des Typs %qT kann nicht mit zusammengesetztem Literal initialisiert werden

en: cannot initialize arrays using this syntax
de: mit dieser Syntax können keine Felder initialisiert werden

en: cannot initialize multi-dimensional array with initializer
de: mehrdimensionales Feld kann nicht initialisiert werden

en: cannot inline function %<main%>
de: %<main%> ist nicht als »inline« möglich

en: cannot inline interrupt function %qE
de: Interruptfunktion %qE kann nicht »inline« sein

en: cannot load plugin %s
    %s
de: Plugin %s kann nicht geladen werden
    %s

en: cannot merge separate %s counters for function %u
de: separate %s Zähler für die Funktion %u können nicht verschmolzen werden

en: cannot open %s
de: Es ist nicht möglich, »%s« zu öffnen

en: cannot optimize loop, the loop counter may overflow
de: Schleife kann nicht optimiert werden, Schleifen-Zählvariable könnte überlaufen

en: cannot optimize possibly infinite loops
de: mögliche Endlosscheife kann nicht optimiert werden

en: cannot pass argument in vector register because altivec instructions are disabled, use -maltivec to enable them
de: Argument kann nicht in Vektorregister übergegeben werden, da AltiVec-Befehle ausgeschaltet sind; -maltivec schaltet sie ein

en: cannot pass objects of non-trivially-copyable type %q#T through %<...%>
de: Objekte des nicht trivial kopierbaren Typs %q#T können nicht über %<...%> übergeben werden

en: cannot pass rvalue to reference parameter
de: R-Wert kann nicht an Referenzparameter übergeben werden

en: cannot put object with volatile field into register
de: Objekt mit volatile-Feld kann nicht in Register geladen werden

en: cannot receive objects of non-trivially-copyable type %q#T through %<...%>;
de: Objekte des nicht trivial kopierbaren Typs %q#T können nicht über %<...%> empfangen werden;

en: cannot reload integer constant operand in %<asm%>
de: Ganzzahlkonstantenoperand kann in %<asm%> nicht neu geladen werden

en: cannot resolve overloaded function %qD based on conversion to type %qT
de: überladene Funktion %qD konnte nicht durch Umwandlung in Typ %qT aufgelöst werden

en: cannot return from a handler of a function-try-block of a constructor
de: vom Behandler eines Funktions-try-Blocks eines Konstruktors kann nicht zurückgekehrt werden

en: cannot return value in vector register because altivec instructions are disabled, use -maltivec to enable them
de: Wert kann nicht in Vektorregister zurückgegeben werden, da AltiVec-Befehle ausgeschaltet sind; -maltivec schaltet sie ein

en: cannot set interrupt attribute: no current function
de: Unterbrechungsattribut kann nicht gesetzt werden; keine aktuelle Funktion

en: cannot set interrupt attribute: no such identifier
de: Unterbrechungsattribut kann nicht gesetzt werden: kein solcher Bezeichner

en: cannot specify -o with -c, -S or -E with multiple files
de: -o kann nicht mit -c, -S oder -E mit mehreren Dateien angegeben werden

en: cannot specify both -C and -o
de: -C und -o können nicht zusammen angegeben werden

en: cannot specify both -msep-data and -mid-shared-library
de: -msep-data und -mid-shared-library können nicht zusammen angegeben werden

en: cannot take address of bit-field %qD
de: die Adresse des Bit-Feldes %qD kann nicht ermittelt werden

en: cannot take the address of %<this%>, which is an rvalue expression
de: Adresse von %<this%> kann nicht ermittelt werden, das ein R-Wert-Ausdruck ist

en: cannot use %<::%> in parameter declaration
de: %<::%> kann nicht in Parameterdeklaration verwendet werden

en: cannot use mode %qs for enumeral types
de: Modus %qs kann nicht für Aufzählungstypen verwendet werden

en: cannot use mshared and static together
de: mshared und static können nicht zusammen verwendet werden

en: cannot use mthreads and mlegacy-threads together
de: mthreads und mlegacy-threads können nicht zusammen verwendet werden

en: cannot use small-data accesses for %qs
de: Kleindatenzugriffe für %qs nicht möglich

en: cannot use type %s as type %s
de: Typ %s kann nicht als Typ %s verwendet werden

en: cannot use typeid with -fno-rtti
de: typeid kann nicht mit -fno-rtti verwendet werden

en: cannot use va_start in interrupt function
de: va_start in Unterbrechungsfunktion kann nicht verwendet werden

en: cannot value-initialize array of unknown bound %qT
de: Feld mit unbekannter Grenze %qT kann nicht mit Werten initialisiert werden

en: canonical types differ for identical types %T and %T
de: kanonische Typen unterscheiden sich für identische Typen %T und %T

en: case label %qE not within a switch statement
de: case-Marke %qE nicht innerhalb einer switch-Anweisung

en: case label does not reduce to an integer constant
de: case-Marke reduziert nicht auf Ganzzahlkonstante

en: case label is not an integer constant expression
de: »case«-Marke ist kein konstanter Ganzzahlausdruck

en: case label not within a switch statement
de: case-Marke nicht innerhalb einer switch-Anweisung

en: case label value exceeds maximum value for type
de: case-Marke überschreitet Maximalwert des Typs

en: case label value is less than minimum value for type
de: case-Marke ist kleiner als Minimalwert des Typs

en: case labels not sorted:
de: Case-Marken nicht sortiert:

en: case value %qs not in enumerated type
de: case-Wert %qs nicht in Aufzählungstyp

en: case value %qs not in enumerated type %qT
de: case-Wert %qs nicht in Aufzählungstyp %qT

en: cast adds %q#v qualifier to function type
de: Typumwandlung fügt Qualifizierer %q#v zu Funktionstyp hinzu

en: cast discards %q#v qualifier from pointer target type
de: Typumwandlung streicht Qualifizierer %q#v von Zeiger-Zieltyp

en: cast from %qT to %qT increases required alignment of target type
de: Umwandlung von %qT in %qT erhöht erforderliche Ausrichtung des Zieltyps

en: cast from %qT to %qT loses precision
de: Typumwandlung von %qT nach %qT verliert Genauigkeit

en: cast from function call of type %qT to non-matching type %qT
de: Typumwandlung von Funktionsaufruf des Typs %qT in unpassenden Typen %qT

en: cast from pointer to integer of different size
de: Typkonvertierung von Zeiger auf Ganzzahl anderer Breite

en: cast from type %qT to type %qT casts away qualifiers
de: Umwandlung des Typs %qT in Typ %qT entfernt Qualifizierer

en: cast increases required alignment of target type
de: Typkonvertierung erfordert Ausrichtung des Zieltyps

en: cast specifies array type
de: Typkonvertierung gibt Feldtyp an

en: cast specifies function type
de: Typkonvertierung gibt Funktionstyp an

en: cast to pointer from integer of different size
de: Typkonvertierung in Zeiger von Ganzzahl anderer Breite

en: cast to union type from type not present in union
de: Typkonvertierung in union-Typ von nicht in union vorhandenem Typen

en: casting %qT to %qT does not dereference pointer
de: Umwandlung von %qT in %qT dereferenziert nicht den Zeiger

en: cdecl and thiscall attributes are not compatible
de: Attribute cdecl und thiscall sind nicht verträglich

en: changes meaning of %qD from %q+#D
de: verändert die Bedeutung von %qD von %q+#D

en: char-array initialized from wide string
de: char-Feld mit wide-Zeichenkette initialisiert

en: checksum is %x instead of %x
de: Prüfsumme ist %x statt %x

en: choosing %qD over %qD
de: Wahl von %qD statt %qD

en: circular pointer delegation detected
de: ringförmige Zeigerdelegation erkannt

en: cl_target_option size mismatch in LTO reader and writer
de: unpassende Größe von cl_target_option in LTO-Leser und -Schreiber

en: class %qE already exists
de: Klasse %qE existiert bereits

en: class %qE is deprecated
de: Klasse %qE ist veraltet

en: class %qT does not have any field named %qD
de: Klasse %qT hat keinen Feldnamen %qD

en: class %qT is implicitly friends with itself
de: Klasse %qT ist implizit »friend« von ihr selbst

en: class %qT will be considered nearly empty in a future version of GCC
de: Klasse %qT wird in zukünftigen GCC-Versionen als annähernd leer betrachtet werden

en: class %qs does not implement the %qE protocol
de: Klasse %qs implementiert nicht das Protokoll %qE

en: class '%s' has no method named '%s' matching signature '%s'
de: Klasse »%s« hat keine Methode namens »%s«, die zur Signatur »%s« passt

en: class definition may not be declared a friend
de: Klassendefinition darf nicht als »friend« deklariert sein

en: cleanup argument not a function
de: Argument für cleanup ist keine Funktion

en: cleanup argument not an identifier
de: Argument für cleanup ist kein Bezeichner

en: closing dependency file %s: %m
de: Abhängigkeitsdatei »%s« wird geschlossen: %m

en: code model %qs not supported in the %s bit mode
de: Codemodell %qs wird im %s-Bit-Modus nicht unterstützt

en: code model %s does not support PIC mode
de: Codemodell %s unterstützt keinen PIC-Modus

en: collapse argument needs positive constant integer expression
de: Collapse-Argument erfordert positiven konstanten Ganzzahlausdruck

en: collapsed loops not perfectly nested
de: zusammengelegte Schleifen sind nicht perfekt geschachtelt

en: collect2 version %s
de: collect2-Version %s

en: collect: reading %s
de: sammeln: %s wird gelesen

en: collect: recompiling %s
de: sammeln: %s wird neu kompiliert

en: collect: relinking
de: sammeln: neu binden

en: collect: tweaking %s in %s
de: sammeln: %s wird in %s eingestellt

en: collection in fast enumeration is not an object
de: Sammlung in schneller Aufzählung ist kein Objekt

en: comma at end of enumerator list
de: Komma am Ende der Aufzählungsliste

en: command line option %qs is not supported by this configuration
de: Kommandozeilenoption %qs wird von dieser Konfiguration nicht unterstützt

en: command line option %qs is valid for %s but not for %s
de: Kommandozeilenoption %qs ist gültig für %s, aber nicht für %s

en: command line option %qs is valid for the driver but not for %s
de: Kommandozeilenoption %qs ist gültig für den Treiber, aber nicht für %s

en: comparing final insns dumps
de: Vergleich der endgültigen Answeisungslisten

en: comparing floating point with == or != is unsafe
de: Vergleich von Gleitkomma mit == oder != ist unsicher

en: comparison always false due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »unwahr«

en: comparison always true due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »wahr«

en: comparison between %q#T and %q#T
de: Vergleich zwischen %q#T und %q#T

en: comparison between %qT and %qT
de: Vergleich zwischen %qT und %qT

en: comparison between distinct pointer types %qT and %qT lacks a cast
de: Vergleich zwischen den unterschiedlichen Zeigertypen %qT und %qT benötigt Umwandlung

en: comparison between distinct pointer-to-member types %qT and %qT lacks a cast
de: beim Vergleich zwischen unterschiedlichen Zeiger-auf-Element-Typen %qT und %qT fehlt eine Typkonvertierung

en: comparison between pointer and integer
de: Vergleich zwischen Zeiger und Ganzzahl

en: comparison between signed and unsigned integer expressions
de: Vergleich zwischen vorzeichenbehafteten und vorzeichenlosen Ganzzahlausdrücken

en: comparison between types %qT and %qT
de: Vergleich zwischen den Typen %qT und %qT

en: comparison is always %d
de: Vergleich ist immer %d

en: comparison is always %d due to width of bit-field
de: Vergleich ist immer %d wegen Breite des Bitfeldes

en: comparison is always false due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »unwahr«

en: comparison is always true due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »wahr«

en: comparison of complete and incomplete pointers
de: Vergleich von vollständigen und unvollständigen Zeigern

en: comparison of distinct Objective-C types lacks a cast
de: Im Vergleich verschiedener Objective-C-Typen fehlt Typumwandlung

en: comparison of distinct pointer types lacks a cast
de: in Vergleich verschiedener Zeigertypen fehlt Typkonvertierung

en: comparison of pointers to disjoint address spaces
de: Vergleich von Zeigern auf disjunkte Adressräume

en: comparison of promoted ~unsigned with constant
de: Vergleich von weitergegebenem ~unsigned mit Konstante

en: comparison of promoted ~unsigned with unsigned
de: Vergleich von weitergegebenem ~unsigned mit unsigned

en: comparison of unsigned expression < 0 is always false
de: Vergleich eines vorzeichenlosen Ausdrucks < 0 ist stets »unwahr«

en: comparison of unsigned expression >= 0 is always true
de: Vergleich eines vorzeichenlosen Ausdrucks >= 0 ist stets »wahr«

en: comparison with string literal results in unspecified behavior
de: Vergleich mit Zeichenkettenliteral führt zu unspezifiziertem Verhalten

en: comparison with string literal results in unspecified behaviour
de: Vergleich mit Zeichenkettenliteral führt zu undefiniertem Verhalten

en: comparisons like %<X<=Y<=Z%> do not have their mathematical meaning
de: Vergleiche wie %<X<=Y<=Z%> haben nicht ihre mathematische Bedeutung

en: compilation terminated due to -Wfatal-errors.
de: Kompilierung wegen -Wfatal-errors beendet.

en: compilation terminated due to -fmax-errors=%u.
de: Kompilierung wegen -fmax-errors=%u beendet.

en: compilation terminated.
de: Kompilierung beendet.

en: complex arguments must have floating-point type
de: komplexe Argumente müssen Gleitkommatyp haben

en: complex arguments must have identical types
de: komplexe Argumente müssen identische Typen haben

en: complex floating point overflow in expression
de: komplexer Gleitkommaüberlauf in Ausdruck

en: complex integer overflow in expression
de: komplexer Ganzzahlüberlauf in Ausdruck

en: complex invalid for %qs
de: complex ungültig für %qs

en: compound literal has variable size
de: zusammengesetztes Literal hat variable Größe

en: compound literal of non-object type %qT
de: zusammengesetztes Literal vom Nicht-Objekt-Typ %qT

en: compound literal qualified by address-space qualifier
de: Verbundliteral durch Adressraumqualifizierer qualifiziert

en: compressed stream: %s
de: komprimierter Strom: %s

en: conditional expression between distinct pointer types %qT and %qT lacks a cast
de: Bedingungsausdruck mit den unterschiedlichen Zeigertypen %qT und %qT benötigt Umwandlung

en: conditional expression between distinct pointer-to-member types %qT and %qT lacks a cast
de: im Bedingungsausdruck mit unterschiedlichen Zeiger-auf-Element-Typen %qT und %qT fehlt eine Typkonvertierung

en: conflicting access specifications for field %qE, ignored
de: Zugriffsangaben für Feld %qE stehen in Konflikt, ignoriert

en: conflicting access specifications for method %q+D, ignored
de: Zugriffsangaben für Methode %q+D stehen in Konflikt, ignoriert

en: conflicting declaration %q#D
de: in Konflikt stehende Deklaration %q#D

en: conflicting named address spaces (%s vs %s)
de: in Konflikt stehende benannte Adressräume (%s und %s)

en: conflicting named address spaces (%s vs %s) for %q+D
de: in Konflikt stehende benannte Adressräume (%s und %s) für %q+D

en: conflicting named address spaces (%s vs generic) for %q+D
de: in Konflikt stehende benannte Adressräume (%s und generisch) für %q+D

en: conflicting named address spaces (generic vs %s) for %q+D
de: in Konflikt stehende benannte Adressräume (generisch und %s) für %q+D

en: conflicting return type specified for %q+#D
de: in Konflikt stehenden Rückgabetyp für %q+#D angegeben

en: conflicting specifiers in declaration of %qs
de: in Konflikt stehende Spezifikationen für Deklaration von %qs

en: conflicting super class name %qE
de: in Konflikt stehender Basisklassenname %qE

en: conflicting type attributes specified for %q+#D
de: in Konflikt stehenden Typattribute für %q+#D angegeben

en: conflicting type qualifiers for %q+D
de: In Konflikt stehende Typqualifizierer für %q+D

en: conflicting types for %<%c%s%>
de: in Konflikt stehende Typen für %<%c%s%>

en: conflicting types for %q+D
de: In Konflikt stehende Typen für %q+D

en: conflicting types for built-in function %q+D
de: In Konflikt stehende Typen für eingebaute Funktion %q+D

en: conflicts with built-in declaration %q#D
de: steht mit eingebauter Deklaration %q#D in Konflikt

en: conflicts with function declaration %q#D
de: steht mit Funktionsdeklaration %q#D in Konflikt

en: conflicts with new declaration with %qL linkage
de: steht mit neuer Deklaration mit %qL-Bindung in Konflikt

en: conflicts with previous declaration %q+#D
de: steht mit vorheriger Deklaration %q+#D in Konflikt

en: conflicts with previous declaration here
de: in Konflikt mit vorheriger Deklaration hier

en: consider using '-pg' instead of '-p' with gprof(1)
de: evtl. »-pg« statt »-p« mit gprof(1) verwendet

en: const %qs cannot be declared %<mutable%>
de: Konstante %qs kann nicht als %<mutable%> deklariert sein

en: const/copy propagation disabled
de: Übertragung von const/copy ausgeschaltet

en: const_double_split got a bad insn:
de: const_double_split bekam einen falschen Befehl:

en: constant argument out of range for %qs
de: Konstantes Argument außerhalb des Wertebereiches für %qs

en: constant field %qD used as %<asm%> output
de: konstantes Feld %qD als %<asm%>-Ausgabe verwendet

en: constant not recomputed when ADDR_EXPR changed
de: Konstante wird bei ADDR_EXPR-Änderung nicht neu berechnet

en: constant refers to itself
de: Konstante verweist auf sich selbst

en: constexpr constructor does not have empty body
de: Konstruktor mit konstantem Ausdruck hat keinen leeren Körper

en: constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to increase the maximum)
de: Auswertungstiefe des konstanten Ausdrucks überschreitet Höchstwert %d (-fconstexpr-depth= verwenden, um dies zu erhöhen)

en: constexpr static data member %qD must have an initializer
de: statisches Datenelement %qD (constexpr) muss Initialisierung haben

en: constructor for alien class %qT cannot be a member
de: Konstruktor für fremde Klasse %qT kann kein Element sein

en: constructor is not user-provided because it is explicitly defaulted in the class body
de: Konstruktor ist nicht benutzerdefiniert, da er im Klassenkörper ausdrücklich standardisiert ist

en: constructor priorities are not supported
de: Konstruktorprioritäten werden nicht unterstützt

en: constructor priorities from 0 to %d are reserved for the implementation
de: Konstruktorprioritäten von 0 bis %d sind für die Implementierung vorbehalten

en: constructor priorities must be integers from 0 to %d inclusive
de: Konstruktorprioritäten müssen Ganzzahlen von 0 bis einschließlich %d sein

en: constructor syntax used, but no constructor declared for type %qT
de: Konstruktorsyntax verwendet, aber kein Konstruktor für Typ %qT deklariert

en: constructors cannot be declared virtual
de: Konstruktoren können nicht als virtuell deklariert werden

en: continue statement not within a loop
de: continue-Anweisung nicht innerhalb einer Schleife

en: continue statement not within loop or switch
de: continue-Anweisung nicht innerhalb einer Schleife oder »switch«

en: control flow in the middle of basic block %d
de: Kontrollfluss inmitten des Basis-Blockes %d

en: control reaches end of non-void function
de: Kontrollfluss erreicht Ende von Nicht-void-Funktion

en: conversion between distinct pointer types %qT and %qT lacks a cast
de: Umwandlung zwischen den unterschiedlichen Zeigertypen %qT und %qT benötigt Umwandlung

en: conversion between distinct pointer-to-member types %qT and %qT lacks a cast
de: bei Umwandlung zwischen unterschiedlichen Zeiger-auf-Element-Typen %qT und %qT fehlt eine Typkonvertierung

en: conversion casts away constness
de: Umformung verwirft Konstantheit

en: conversion from %q#T to %q#T
de: Umwandlung von %q#T nach %q#T

en: conversion from %qT to %qT discards qualifiers
de: Umwandlung von %qT in %qT löscht Qualifizierer

en: conversion from %qT to %qT is ambiguous
de: Umformung von %qT in %qT ist nicht eindeutig

en: conversion from %qT to %qT not considered for non-type template argument
de: Umwandlung von %qT in %qT für Nicht-Typ-Templateargument nicht betrachtet

en: conversion from %qT to non-scalar type %qT requested
de: Umwandlung von %qT in nicht-skalaren Typen %qT angefordert

en: conversion lacks type at end of format
de: bei der Konvertierung fehlt der Typ am Ende des Formates

en: conversion of %qE from %qT to %qT is ambiguous
de: Umwandlung von %qE von %qT nach %qT ist mehrdeutig

en: conversion of an SSA_NAME on the left hand side
de: Umwandlung eines SSA_NAME auf der linken Seite

en: conversion of expression %qE of pointer type cannot yield a constant expression
de: Umwandlung des Ausdrucks %qE mit Zeigertyp kann keinen konstanten Ausdruck ergeben

en: conversion of register to a different size
de: Umwandlung eines Registers auf eine andere Größe

en: conversion of unsigned constant value to negative integer
de: Umwandlung eines vorzeichenlosen konstanten Wertes in negative Ganzzahl

en: conversion to %qT alters %qT constant value
de: Umformung in %qT ändert konstanten Wert von %qT

en: conversion to %qT from %qT may alter its value
de: Umwandlung in %qT von %qT könnte den Wert ändern

en: conversion to %qT from %qT may change the sign of the result
de: Umwandlung in %qT von %qT könnte das Vorzeichen des Ergebnisses ändern

en: conversion to %qT from boolean expression
de: Umwandlung in %qT aus boolschem Ausdruck

en: conversion to a base class will never use a type conversion operator
de: Umwandlung in Basisklasse wird nie einen Typumwandlungsoperator verwenden

en: conversion to a reference to a base class will never use a type conversion operator
de: Umwandlung in Referenz auf Basisklasse wird nie einen Typumwandlungsoperator verwenden

en: conversion to a reference to the same type will never use a type conversion operator
de: Umwandlung in Referenz auf gleichen Typ wird nie einen Typumwandlungsoperator verwenden

en: conversion to a reference to void will never use a type conversion operator
de: Umwandlung in Referenz auf void wird nie einen Typumwandlungsoperator verwenden

en: conversion to incomplete type
de: Konvertierung in unvollständigen Typen

en: conversion to non-const reference type %q#T from rvalue of type %qT
de: Umwandlung in nicht-konstanten Referenztyp %q#T von R-Wert des Typs %qT

en: conversion to non-scalar type requested
de: Konvertierung zu Nicht-Skalar-Typ verlangt

en: conversion to the same type will never use a type conversion operator
de: Umwandlung in gleichen Typ wird nie einen Typumwandlungsoperator verwenden

en: conversion to void cannot resolve address of overloaded function
de: Umwandlung in void kann die Adresse der überladenen Funktion nicht auflösen

en: conversion to void will never use a type conversion operator
de: Umwandlung in void wird nie einen Typumwandlungsoperator verwenden

en: conversion to void will not access object %qE of incomplete type %qT
de: Umwandlung in void greift nicht auf Objekt %qE des unvollständigen Typs %qT zu

en: conversion to void will not access object of incomplete type %qT
de: Umwandlung in void greift nicht auf Objekt des unvollständigen Typs %qT zu

en: conversion to void will not access object of non-trivially-copyable type %qT
de: Umwandlung in void greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT zu

en: conversion to void will not access object of type %qT
de: Umwandlung in void greift nicht auf Objekt des Typs %qT zu

en: conversion to volatile reference type %q#T from rvalue of type %qT
de: Umwandlung in »volatile« Referenztyp %q#T von R-Wert des Typs %qT

en: converting %<false%> to pointer type for argument %P of %qD
de: %<false%> wird für Argument %P von %qD in Zeigertyp umgewandelt

en: converting NULL to non-pointer type
de: Umwandlung von NULL in Nicht-Zeiger-Typ

en: converting from %qT to %qT
de: Umwandlung von %qT nach %qT

en: converting lambda which uses %<...%> to function pointer
de: %<...%> verwendendes Lambda wird in Funktionszeiger umgewandelt

en: converting overloaded function %qD to type %q#T is ambiguous
de: Umwandung der überladenen Funktion %qD in den Typ %q#T ist mehrdeutig

en: converting to %qT from initializer list would use explicit constructor %qD
de: Umwandlung in %qT von Initialisierungsliste würde expliziten Konstruktor %qD verwenden

en: converting to non-pointer type %qT from NULL
de: Konvertierung in Nicht-Zeiger-Typ %qT von NULL

en: coprocessor intrinsic %qs is not available in this configuration
de: Koprozessor-eigenes %qs ist in dieser Konfiguration nicht verfügbar

en: coprocessor not enabled
de: Koprozessor nicht eingeschaltet

en: correcting inconsistent profile data
de: inkonsistente Profildaten werden korrigiert

en: correcting inconsistent value profile: %s profiler overall count (%d) does not match BB count (%d)
de: unstimmiges Werteprofil wird korrigiert: %s-Profiler-Gesamtzähler (%d) passt nicht zum BB-Zähler (%d)

en: corrupted exits list of loop %d
de: beschädigte Ausgangsliste der Schleife %d

en: corrupted head of the exits list of loop %d
de: beschädigter Kopf der Ausgangsliste von Schleife %d

en: corrupted profile info: edge count exceeds maximal count
de: beschädigte Profilinfo: Kantenzahl überschreitet Höchstzahl

en: corrupted profile info: edge from %i to %i exceeds maximal count
de: Info zum beschädigten Profil: Kante von %i nach %i überschreitet Höchstzahl

en: corrupted profile info: number of executions for edge %d-%d thought to be %i
de: Info zum beschädigten Profil: Anzahl der Ausführungen der Kante »%d-%d« sollte %i sein

en: corrupted profile info: number of iterations for basic block %d thought to be %i
de: Info zum beschädigten Profil: Anzahl der Durchläufe des Basisblocks %d sollte %i sein

en: corrupted profile info: profile data is not flow-consistent
de: Info zum beschädigten Profil: Profildaten sind nicht Fluss-konsistent

en: corrupted profile info: run_max * runs < sum_max
de: beschädigte Profilinformation: run_max * runs < sum_max

en: corrupted profile info: sum_all is smaller than sum_max
de: beschädigte Profilinformation: sum_all ist kleiner als sum_max

en: corrupted value profile: %s profile counter (%d out of %d) inconsistent with basic-block count (%d)
de: beschädigtes Werteprofil: %s-Profiler-Gesamtzähler (%d aus %d) passt nicht zum BB-Zähler (%d)

en: could not close Go dump file: %m
de: Go-Abzugsdatei konnte nicht geschlossen werden: %m

en: could not close final insn dump file %qs: %m
de: endgültige Abzugsdatei %qs der Anweisungen konnte nicht geschlossen werden: %m

en: could not close response file %s
de: Antwortdatei %s konnte nicht geschlossen werden

en: could not close temporary response file %s
de: temporäre Antwortdatei %s konnte nicht geschlossen werden

en: could not close zeroed insn dump file %qs: %m
de: Abzugsdatei %qs genullter Befehle konnte nicht geschlossen werden: %m

en: could not convert %qE from %qT to %qT
de: %qE konnte nicht von %qT nach %qT umgewandelt werden

en: could not convert template argument %qE to %qT
de: Templateargument %qE konnte nicht in %qT umgewandelt werden

en: could not find a spill register
de: es konnte kein Überlaufregister gefunden werden

en: could not find class %qE
de: Klasse %qE kann nicht gefunden werden

en: could not find class$ field in java interface type %qT
de: class$-Feld konnte nicht im Java-Schnittstellentyp %qT gefunden werden

en: could not find interface for class %qE
de: Schnittstelle für Klasse %qE kann nicht gefunden werden

en: could not find setter/getter for %qE in class %qE
de: Setter/Getter für %qE in Klasse %qE kann nicht gefunden werden

en: could not find specs file %s
de: Spezifikationsdatei %s konnte nicht gefunden werden

en: could not open Go dump file %qs: %m
de: Go-Abzugsdatei %qs konnte nicht geöffnet werden: %m

en: could not open dump file %qs: %m
de: Abzugsdatei %qs konnte nicht geöffnet werden: %m

en: could not open final insn dump file %qs: %m
de: endgültige Abzugsdatei %qs der Anweisungen konnte nicht geöffnet werden: %m

en: could not open response file %s
de: Antwortdatei %s konnte nicht geöffnet werden

en: could not open temporary response file %s
de: temporäre Antwortdatei %s konnte nicht geöffnet werden

en: could not resolve typename type
de: Typnamen-Typ kann nicht aufgelöst werden

en: could not split insn
de: Befehl kann nicht aufgeteilt werden

en: could not write to response file %s
de: in Antwortdatei %s konnte nicht geschrieben werden

en: could not write to temporary file %s
de: in temporäre Datei %s konnte nicht geschrieben werden

en: could not write to temporary response file %s
de: in temporäre Antwortdatei %s konnte nicht geschrieben werden

en: couldn%'t understand kern.osversion %q.*s
de: kern.osversion nicht erkannt: %q.*s

en: couldn%'t unmap pch_address_space: %m
de: Abbildung von pch_address_space konnte nicht aufgehoben werden: %m

en: coverage mismatch for function %qE while reading counter %qs
de: Überdeckung passt nicht für Funktion %qE beim Lesen des Zählers %qs

en: coverage mismatch for function %u while reading execution counters
de: Überdeckung passt nicht für Funktion %u beim Lesen der Ausführungszähler

en: coverage mismatch ignored
de: unpassende Überdeckung ignoriert

en: created and used with different ABIs
de: erzeugt und mit anderen ABIs verwendet

en: created and used with different architectures / ABIs
de: erzeugt und mit anderen Architekturen / ABIs verwendet

en: created and used with different endianness
de: erzeugt und mit anderer Bytereihenfolge verwendet

en: created and used with different settings of -fpic
de: erzeugt und mit anderen Einstellungen von -fpic verwendet

en: created and used with different settings of -fpie
de: erzeugt und mit anderen Einstellungen von -fpie verwendet

en: created and used with differing settings of '%s'
de: erzeugt und mit anderen Einstellungen von »%s« verwendet

en: creating array of %qT
de: Feld von %qT wird erzeugt

en: creating array of %qT, which is an abstract class type
de: Feld von %qT wird erzeugt, was ein abstrakter Klassentyp ist

en: creating array of function members
de: Feld von Funktionselementen wird erzeugt

en: creating array of functions
de: Feld von Funktionen wird erzeugt

en: creating array of references
de: Feld von Referenzen wird erzeugt

en: creating array of void
de: Feld von void wird erzeugt

en: creating pointer to member function of non-class type %qT
de: Erzeugung eines Zeigers auf Elementfunktion des Nicht-Klassentyps %qT

en: creating pointer to member of non-class type %qT
de: Zeiger auf Element des Nicht-Klassentypen %qT wird erzeugt

en: creating pointer to member of type void
de: Zeiger auf Element mit Typ »void« wird erzeugt

en: creating pointer to member reference type %qT
de: Zeiger auf Elementreferenztyp %qT wird erzeugt

en: creating run-time relocation
de: Laufzeit-Relocation wird erzeugt

en: creating run-time relocation for %qD
de: Laufzeit-Relocation für %qD wird erzeugt

en: creating selector for nonexistent method %qE
de: für nicht existierende Methode %qE wird Selektor erzeugt

en: critical region may not be nested inside a critical region with the same name
de: kritische Region darf nicht innerhalb einer kritischen Region mit gleichem Namen geschachtelt werden

en: current namespace %qD does not enclose strongly used namespace %qD
de: aktueller Namensbereich %qD schließt nicht stark verwendeten Namensbereich %qD ein

en: data area attributes cannot be specified for local variables
de: Datenbereichsattribute können nicht für lokale Variablen angegeben werden

en: data area of %q+D conflicts with previous declaration
de: Datenbereich von %q+D in Konflikt mit vorheriger Deklaration

en: data declaration
de: Daten-Deklaration

en: data definition has no type or storage class
de: Datendefinition hat keinen Typ oder Speicherklasse

en: data member %qD cannot be a member template
de: Datenelement %qD kann kein Elementtemplate sein

en: data member may not have variably modified type %qT
de: Datenelement darf nicht variabel modifizierten Typ %qT haben

en: data type of %q+D isn%'t suitable for a register
de: Datentyp von %q+D ist nicht für Register geeignet

en: dead STMT in EH table
de: totes STMT in EH-Tabelle

en: dead histogram
de: totes Histogramm

en: debug format "%s" conflicts with prior selection
de: Testformat »%s« steht in Konflikt mit vorheriger Auswahl

en: debug output level %s is too high
de: Testausgabestufe »%s« ist zu groß

en: debug:
de: zur Fehlersuche:

en: decl-specifier invalid in condition
de: decl-Spezifizierung in Bedingung ungültig

en: declaration %qD does not declare anything
de: Deklaration %qD deklariert nichts

en: declaration does not declare anything
de: Deklaration deklariert nichts

en: declaration for parameter %qD but no such parameter
de: Deklaration für nicht vorhandenen Parameter %qD

en: declaration of %<extern%> variable %qD in %<for%> loop initial declaration
de: Deklaration der %<extern%>-Variablen %qD in Anfangsdeklaration einer %<for%>-Schleife

en: declaration of %<~%T%> as member of %qT
de: Deklaration von %<~%T%> als Element von %qT

en: declaration of %q#D
de: Deklaration von %q#D

en: declaration of %q#D has %<extern%> and is initialized
de: Deklaration von %q#D hat %<extern%> und ist initialisiert

en: declaration of %q#D has no initializer
de: Deklaration von %q#D hat keine Initialisierung

en: declaration of %q#D outside of class is not definition
de: Deklaration von %q#D außerhalb einer Klasse ist keine Definition

en: declaration of %q#D shadows a parameter
de: Deklaration von %q#D überdeckt einen Parameter

en: declaration of %q#D with C language linkage
de: Deklaration von %q#D mit C-Sprachen-Bindung

en: declaration of %q+#D
de: Deklaration von %q+#D

en: declaration of %q+#T
de: Deklaration von %q+#T

en: declaration of %q+D shadows a built-in function
de: Deklaration von %q+D überdeckt eine eingebaute Funktion

en: declaration of %q+D shadows a global declaration
de: Deklaration von %q+D überdeckt eine globale Deklaration

en: declaration of %q+D shadows a parameter
de: Deklaration von %q+D überdeckt einen Parameter

en: declaration of %q+D shadows a previous local
de: Deklaration von %q+D überdeckt einen vorhergehenden lokalen Bezeichner

en: declaration of %q+D shadows previous non-variable
de: Deklaration von %q+D überdeckt eine vorhergehende Nicht-Variable

en: declaration of %q+D with attribute noinline follows inline declaration
de: Deklaration von %q+D mit Attribut noinline folgt inline-Deklaration

en: declaration of %q+D with no linkage follows extern declaration
de: Deklaration von %q+D ohne Bindung folgt einer extern-Deklaration

en: declaration of %qD as array of function members
de: Deklaration von %qD als Feld von Funktionselementen

en: declaration of %qD as array of functions
de: Deklaration von %qD als Feld von Funktionen

en: declaration of %qD as array of references
de: Deklaration von %qD als Feld von Referenzen

en: declaration of %qD as array of void
de: Deklaration von %qD als Feld von voids

en: declaration of %qD as member of %qT
de: Deklaration von %qD als Element %qT

en: declaration of %qD as multidimensional array must have bounds for all dimensions except the first
de: Deklaration von %qD als multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben

en: declaration of %qD as non-function
de: Deklaration von %qD als Nicht-Funktion

en: declaration of %qD as non-member
de: Deklaration von %qD als Nicht-Element

en: declaration of %qD in %qD which does not enclose %qD
de: Deklaration von %qD in %qD, das nicht %qD einschließt

en: declaration of %qD in namespace %qD which does not enclose %qD
de: Deklaration von %qD in Namensraum %qD, der nicht %qD einschließt

en: declaration of %qD not in a namespace surrounding %qD
de: Deklaration von %qD nicht in einem Namensbereich um %qD

en: declaration of %qD shadows a global declaration
de: Deklaration von %qD überdeckt eine globale Deklaration

en: declaration of %qD shadows a member of 'this'
de: Deklaration von %qD überdeckt ein Element von 'this'

en: declaration of %qD shadows a previous local
de: Deklaration von %qD überdeckt einen vorhergehenden lokalen Bezeichner

en: declaration of %qE as array of functions
de: Deklaration von %qE als Feld von Funktionen

en: declaration of %qE as array of voids
de: Deklaration von %qE als Feld von voids

en: declaration of %qF has a different exception specifier
de: Deklaration von %qF hat eine andere Ausnahmen-Spezifikation

en: declaration of C function %q#D conflicts with
de: Deklaration der C-Funktion %q#D steht in Konflikt mit

en: declaration of constexpr variable %qD is not a definition
de: Deklaration der constexpr-Variable %qD ist keine Definition

en: declaration of function %qD in invalid context
de: Deklaration der Funktion %qD in ungültigem Kontext

en: declaration of namespace %qD conflicts with
de: Deklaration von namespace %qD steht in Konflikt mit

en: declaration of non-variable %qD in %<for%> loop initial declaration
de: Deklaration der Nicht-Variablen %qD in Anfangsdeklaration einer %<for%>-Schleife

en: declaration of static variable %qD in %<for%> loop initial declaration
de: Deklaration der »static«-Variablen %qD in Anfangsdeklaration einer %<for%>-Schleife

en: declaration of template %q#D
de: Deklaration des Templates %q#D

en: declaration of type name as array of functions
de: Deklaration eines Typnamen als Feld von Funktionen

en: declaration of type name as array of voids
de: Deklaration eines Typnamen als Feld von voids

en: declarator-id missing; using reserved word %qD
de: Deklarator-ID fehlt: reserviertes Wort %qD wird verwendet

en: declared here
de: hier deklariert

en: decrement of constant field %qD
de: Verringerung des konstanten Feldes %qD

en: decrement of enumeration value is invalid in C++
de: Verringerung von Aufzählungswerten (enum) ist in C++ ungültig

en: decrement of function %qD
de: Verringerung der Funktion %qD

en: decrement of member %qD in read-only object
de: Verringerung des Elements %qD in schreibgeschütztem Objekt

en: decrement of pointer to unknown structure
de: Verminderung eines Zeigers auf unbekannte Struktur

en: decrement of read-only location %qE
de: Verringerung der schreibgeschützten Speicherstelle %qE

en: decrement of read-only member %qD
de: Verringerung des schreibgeschützten Elementes %qD

en: decrement of read-only named return value %qD
de: Verringerung des schreibgeschützten benannten Rückgabewertes %qD

en: decrement of read-only parameter %qD
de: Verringerung des schreibgeschützten Parameters %qD

en: decrement of read-only reference %qD
de: Verringerung der schreibgeschützten Referenz %qD

en: decrement of read-only variable %qD
de: Verringerung der schreibgeschützten Variable %qD

en: deducing %qT as %qT
de: %qT ermittelt als %qT

en: deducing from brace-enclosed initializer list requires #include <initializer_list>
de: Ermittlung aus geschweift geklammerter Initialisierungsliste erfordert #include <initializer_list>

en: default argument %qE uses local variable %qD
de: Standardargument %qE verwendet lokale Variable %qD

en: default argument for %q#D has type %qT
de: Standardargument für %q#D hat Typ %qT

en: default argument for parameter of type %qT has type %qT
de: Standardargument für Parameter des Typs %qT hat Typ %qT

en: default argument for template parameter for class enclosing %qD
de: Standardargument für Template-Parameter für %qD umschließende Klasse

en: default argument given for parameter %d of %q#D
de: Standardargument für Parameter %d von %q#D angegeben

en: default argument mismatch in overload resolution
de: Zuordnungsfehler der Standardargumente in Überladungsauflösung

en: default argument missing for parameter %P of %q+#D
de: Standardargument fehlt für Parameter %P von %q+#D

en: default argument specified for lambda parameter
de: Standardargument für Lambda-Parameter angegeben

en: default argument specified in explicit specialization
de: Standardargument in expliziter Spezialisierung angegeben

en: default arguments are not allowed in declaration of friend template specialization %qD
de: Standardargumente sind nicht in Deklaration der friend-Template-Spezialisierung %qD erlaubt

en: default arguments are only permitted for function parameters
de: Standardargumente sind nur für Funktionsparameter zugelassen

en: default template arguments may not be used in function template friend declarations
de: Standardtemplateargumente dürfen in friend-Deklaration eines Funktionstemplates nicht verwendet werden

en: default template arguments may not be used in function template friend re-declaration
de: Standardtemplateargumente dürfen in friend-Redeklaration eines Funktionstemplates nicht verwendet werden

en: default template arguments may not be used in function templates without -std=c++0x or -std=gnu++0x
de: Standardtemplateargumente dürfen in Funktionstemplates ohne -std=c++0x und -std=gnu++0x nicht verwendet werden

en: default template arguments may not be used in partial specializations
de: Standardtemplateargumente dürfen in teilweiser Spezialisierung nicht verwendet werden

en: defaulted and deleted functions only available with -std=c++0x or -std=gnu++0x
de: Standard- und gelöschte Funktionen nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: defaulted declaration %q+D
de: Vorgabe-Deklaration %q+D

en: defaulted function %q+D with default argument
de: vorgegebene Funktion %q+D mit Standardargument

en: defaulting to stack for %s register creation
de: Erzeugung von Register %s erfolgt auf Stack

en: defining a type in a cast is invalid in C++
de: Definition eines Typs in einer Umwandlung ist in C++ ungültig

en: defining a type in a compound literal is invalid in C++
de: Definition eines Typs in einem zusammengesetzten Literal ist in C++ ungültig

en: defining explicit specialization %qD in friend declaration
de: Definition der expliziten Spezialisierung %qD in friend-Deklaration

en: defining type in %qs expression is invalid in C++
de: Typdefinition in Ausdruck %qs ist in C++ ungültig

en: definition in block %i does not dominate use in block %i
de: Definition in Block %i herrscht nicht vor in Block %i

en: definition in block %i follows the use
de: Definition in Block %i folgt der Verwendung

en: definition of %q#D is marked %<dllimport%>
de: Definition von %q#D ist als »dllimport« markiert

en: definition of %q#T inside template parameter list
de: Definition von %q#T in Templateparameterliste

en: definition of %qD is not in namespace enclosing %qT
de: Deklaration von %qD ist nicht in einem Namensbereich um %qT

en: definition of implicitly-declared %qD
de: Definition des implizit deklarierten %qD

en: definition of protocol %qE not found
de: Definition des Protokolls %qE nicht gefunden

en: definition of static data member %q+D of dllimport%'d class
de: Definition des statischen Datenelementes %q+D einer »dllimport«-ierten Klasse

en: definition provided for explicit instantiation
de: Definition für explizite Instanziierung angegeben

en: deleted definition of %qD
de: Definition von %qD gelöscht

en: deleted function %q+D
de: Funktion %q+D gelöscht

en: deleting %qT is undefined
de: Löschen von %qT ist nicht definiert

en: deleting LTRANS file %s
de: LTRANS-Datei %s wird gelöscht

en: deleting array %q#D
de: Feld %q#D wird gelöscht

en: dependent-name %qE is parsed as a non-type, but instantiation yields a type
de: Abhängigenname %qE wird als Nicht-Typ erkannt, aber die Instanziierung liefert einen Typ

en: deprecated conversion from string constant to %qT
de: veraltete Konvertierung von Zeichenkettenkonstante in %qT

en: deprecated covariant return type for %q+#D
de: veralteter kovarianter Rückgabetyp für %q+#D

en: deprecated message is not a string
de: Veraltete Meldung ist keine Zeichenkette

en: deprecated use of default argument for parameter of non-function
de: veraltete Verwendung des Standardarguments für Parameter einer Nicht-Funktion

en: dereferencing %<void *%> pointer
de: Dereferenzierung eines %<void *%>-Zeigers

en: dereferencing pointer to incomplete type
de: Dereferenzierung eines Zeigers auf unvollständigen Typen

en: dereferencing type-punned pointer might break strict-aliasing rules
de: Dereferenzierung eines Type-Pun-Zeigers könnte strict-aliasing-Regeln verletzen

en: dereferencing type-punned pointer will break strict-aliasing rules
de: Dereferenzierung eines Type-Pun-Zeigers verletzt strict-aliasing-Regeln

en: derived type declaration
de: Deklaration eines abgeleiteten Typs

en: derived union %qT invalid
de: abgeleitete Union %qT ist ungültig

en: destructor %qD declared as member template
de: Destruktor %qD als Element-Template deklariert

en: destructor cannot be static member function
de: Destruktor kann keine statische Elementfunktion sein

en: destructor for %qE shall not be run either
de: Destruktor für %qE sollte auch nicht abgearbeitet werden

en: destructor for alien class %qT cannot be a member
de: Destruktor für fremde Klasse %qT kann kein Element sein

en: destructor priorities are not supported
de: Destruktorprioritäten werden nicht unterstützt

en: destructor priorities from 0 to %d are reserved for the implementation
de: Destruktorprioritäten von 0 bis %d sind für die Implementierung vorbehalten

en: destructor priorities must be integers from 0 to %d inclusive
de: Destruktorprioritäten müssen Ganzzahlen von 0 bis einschließlich %d sein

en: destructors may not be cv-qualified
de: Destruktoren dürfen nicht CV-qualifiziert sein

en: destructors may not have parameters
de: Destruktoren dürfen keine Parameter haben

en: difference between %qE and %qD does not have integer type
de: Unterschied zwischen %qE und %qD hat keinen Ganzzahltyp

en: difference of two pointer expressions is not a constant expression
de: Unterschied zweier Zeigerausdrücke ist kein konstanter Ausdruck

en: different number of parameters
de: unterschiedliche Parameteranzahl

en: different number of results
de: unterschiedliche Ergebnisanzahl

en: different parameter types
de: unterschiedliche Parametertypen

en: different receiver types
de: unterschiedliche Empfängertypen

en: different result types
de: unterschiedliche Ergebnistypen

en: different underlying type in enum %q#T
de: anderer zugrunde liegender Typ in enum %q#T

en: different varargs
de: unterschiedliche variable Argumente

en: direct base %qT inaccessible in %qT due to ambiguity
de: direkte Basis %qT ist in %qT durch Mehrdeutigkeit unzugänglich

en: distinct Objective-C type in return
de: Anderer Objective-C-Typ in Rückgabe

en: division by zero
de: Division durch Null

en: division by zero is not a constant-expression
de: Division durch Null ist kein konstanter Ausdruck

en: do not specify both -march=... and -mcpu=...
de: nicht gleichzeitig -march=... und -mcpu=... angeben

en: does not match expected signature %qD
de: passt nicht zur erwarteten Signatur %qD

en: does not support multilib
de: unterstützt nicht multilib

en: dominator of %d should be %d, not %d
de: Herrscher über %d sollte %d sein, nicht %d

en: dominator of %d status unknown
de: unbekannter Status für Herrscher über %d

en: double linked list of clones corrupted
de: doppelt verkettete Liste des Clones ist beschädigt

en: due to different exception specifications
de: durch andere Ausnahmespezifikationen

en: duplicate %<const%>
de: doppeltes %<const%>

en: duplicate %<restrict%>
de: doppeltes %<restrict%>

en: duplicate %<volatile%>
de: doppeltes %<volatile%>

en: duplicate %qE
de: doppeltes %qE

en: duplicate %qs
de: doppeltes %qs

en: duplicate (or overlapping) case value
de: Doppelte (oder sich überschneidende) case-Werte

en: duplicate ConstantValue attribute for field '%s'
de: doppeltes ConstantValue-Attribut für Feld »%s«

en: duplicate address region attribute %qE in declaration of %qE on line %d
de: doppeltes Attribut %qE für Adressregion in Deklaration von %qE in Zeile %d

en: duplicate asm operand name %qs
de: doppelter asm-Operandenname %qs

en: duplicate base type %qT invalid
de: doppelter Basistyp %qT ungültig

en: duplicate case value
de: Doppelter case-Wert

en: duplicate cv-qualifier
de: doppelter CV-Qualifizierer

en: duplicate declaration for protocol %qE
de: doppelte Deklaration für Protokoll %qE

en: duplicate declaration of method %<%c%E%> with conflicting types
de: doppelte Deklaration der Methode %<%c%E%> mit in Konflikt stehenden Typen

en: duplicate explicit instantiation of %q#D
de: doppelte explizite Instanziierung von %q#D

en: duplicate explicit instantiation of %q#T
de: doppelte explizite Instanziierung von %q#T

en: duplicate initialization of %qD
de: doppelte Initialisierung von %qD

en: duplicate interface declaration for category %<%E(%E)%>
de: doppelte Schnittstellendeklaration für Kategorie %<%E(%E)%>

en: duplicate interface declaration for class %qE
de: doppelte Schnittstellendeklaration für Klasse %qE

en: duplicate label %qD
de: doppelte Marke %qD

en: duplicate label declaration %qE
de: Doppelte Markendeklaration %qE

en: duplicate member %q+D
de: doppeltes Element %q+D

en: during -fcompare-debug recompilation
de: während Neuübersetzung mit -fcompare-debug

en: dwarf version %d is not supported
de: Dwarf-Version %d wird nicht unterstützt

en: dynamic dependency %s not found
de: dynamische Abhängigkeit %s nicht gefunden

en: dynamic exception specifications are deprecated in C++0x; use %<noexcept%> instead
de: dynamische Ausnahmespezifikationen sind in C++0x veraltet; stattdessen %<noexcept%> verwenden

en: dynamic_cast of %q#D to %q#T can never succeed
de: dynamic_cast von %q#D nach %q#T kann nie erfolgreich sein

en: each undeclared identifier is reported only once for each function it appears in
de: jeder nicht deklarierte Bezeichner wird nur einmal für jede Funktion, in der er vorkommt, gemeldet

en: edge %s->%s has no corresponding call_stmt
de: Kante %s->%s hat keine passende call_stmt

en: edge from %d to %d should be marked irreducible
de: Kante von %d nach %d sollte als irreduzibel markiert werden

en: edge from %d to %d should not be marked irreducible
de: Kante von %d nach %d sollte nicht als irreduzibel markiert werden

en: edge points to same body alias:
de: Kante zeigt auf selben Körper-Alias:

en: edge points to wrong declaration:
de: Kante zeigt auf falsche Deklaration:

en: elaborated-type-specifier for a scoped enum must not use the %<%D%> keyword
de: ausführliche Typ-Spezifikation für einen enum mit Gültigkeitsbereich darf nicht das Schlüsselwort %<%D%> verwenden

en: element types must be the same
de: Elementtypen müssen dieselben sein

en: elemental binary operation
de: Elementare Binäroperation

en: elemental function arguments at %C are not compliant
de: elementare Funktionsargumente bei %C sind nicht konform

en: elemental procedure
de: Elementares Unterprogramm

en: elements of array %q#D have incomplete type
de: Elemente des Feldes %q#D haben unvollständigen Typ

en: elements of array %q#T have incomplete type
de: Elemente des Feldes %q#T haben unvollständigen Typ

en: embedded %<\0%> in format
de: eingebettetes %<\0%> im Format

en: emitting PIC operand, but PIC register isn%'t set up
de: PIC-Operand wird ausgegeben, aber PIC-Register ist nicht vorbereitet

en: emitting conditional microcode insn %s	[%s] #%d
de: Ausgabe der bedingten Mikrocode-Anweisung %s	[%s] #%d

en: emitting microcode insn %s	[%s] #%d
de: Ausgabe der Mikrocode-Anweisung %s	[%s] #%d

en: empty declaration
de: Leere Deklaration

en: empty declaration with storage class specifier does not redeclare tag
de: Leere Deklaration mit Speicherklassenangabe redeklariert nicht Symbol

en: empty declaration with type qualifier does not redeclare tag
de: Leere Deklaration mit Typqualifizierer redeklariert nicht Symbol

en: empty index range in initializer
de: leerer Indexbereich in Initialisierung

en: empty left precision in %s format
de: leere linke Präzision im Format %s

en: empty precision in %s format
de: fehlende Präzision im Format %s

en: empty range specified
de: Leerer Wertebereich angegeben

en: empty scalar initializer
de: leere Skalar-Initialisierung

en: enabled by default
de: standardmäßig aktiviert

en: enabling backtrace support is only meaningful when compiling for the Thumb
de: Das Aktivieren der Ablaufverfolgung ist nur bei der Übersetzung für THUMB sinnvoll

en: enabling callee interworking support is only meaningful when compiling for the Thumb
de: Das Aktivieren der Unterstützung der Aufgerufenen-Zusammenarbeit ist nur bei der Übersetzung für THUMB sinnvoll

en: enclosing class of %q+#D is not a literal type
de: umschließende Klasse von %q+#D ist kein Literaltyp

en: enclosing class templates are not explicitly specialized
de: einschließende Klassentemplates werden nicht explizit spezialisiert

en: enclosing parallel
de: umgebende Parallele

en: enclosing task
de: umgebende Task

en: end insn %d for block %d not found in the insn stream
de: Ende-Befehl %d für Block %d nicht im Befehlsstrom gefunden

en: end of implied-do loop at %L could not be simplified to a constant value
de: Ende der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden

en: enum constant defined here
de: enum-Konstante hier definiert

en: enum conversion in assignment is invalid in C++
de: enum-Umwandlung in Zuweisung ist in C++ ungültig

en: enum conversion in initialization is invalid in C++
de: enum-Umwandlung in Initialisierung ist in C++ ungültig

en: enum conversion in return is invalid in C++
de: enum-Umwandlung in Rückgabe ist in C++ ungültig

en: enum conversion when passing argument %d of %qE is invalid in C++
de: Enum-Umwandlung bei Übergabe des Arguments %d von %qE ist in C++ ungültig

en: enum type defined here
de: »enum«-Typ hier definiert

en: enumeral and non-enumeral type in conditional expression
de: Aufzählungs- und Nicht-Aufzählungstyp in bedingtem Ausdruck

en: enumeral mismatch in conditional expression: %qT vs %qT
de: Aufzählungsfehler in bedingtem Ausdruck: %qT vs. %qT

en: enumeration value %qE not handled in switch
de: Aufzählungswert %qE wird nicht von switch behandelt

en: enumeration values exceed range of largest integer
de: Aufzählungswerte überschreiten Wertebereich des größten Ganzzahltypen

en: enumerator value %E is too large for underlying type %<%T%>
de: Aufzählungswert %E ist zu groß für zugrunde liegenden Typ %<%T%>

en: enumerator value for %qD is not an integer constant
de: Aufzählungswert für %qD ist keine Ganzzahlkonstante

en: enumerator value for %qE is not an integer constant
de: Aufzählungswert für %qE ist keine Ganzzahlkonstante

en: enumerator value for %qE is not an integer constant expression
de: Aufzählungswert für %qE ist kein Ganzzahlkonstantenausdruck

en: environment variable %qs not defined
de: Umgebungsvariable %qs nicht definiert

en: environment variable COLLECT_GCC must be set
de: Umgebungsvariable COLLECT_GCC muss gesetzt sein

en: environment variable COLLECT_GCC_OPTIONS must be set
de: Umgebungsvariable COLLECT_GCC_OPTIONS muss gesetzt sein

en: environment variable DJGPP not defined
de: Umgebungsvariable DJGPP nicht definiert

en: environment variable DJGPP points to corrupt file '%s'
de: Umgebungsvariable DJGPP zeigt auf kaputte Datei »%s«

en: environment variable DJGPP points to missing file '%s'
de: Umgebungsvariable DJGPP zeigt auf fehlende Datei »%s«

en: error closing %s: %m
de: Fehler beim Schließen von %s: %m

en: error in args to spec function %qs
de: Fehler in Argumenten für Spezifikationsfunktion %qs

en: error in constant pool entry #%d
de: Fehler im Konstantenbasiseintrag #%d

en: error while parsing constant pool
de: Fehler beim Analysieren der Konstantenbasis

en: error while parsing constant pool
de: Fehler beim Analysieren der Konstantenbasis

en: error while parsing fields
de: Fehler bei der Analyse der Felder

en: error while parsing fields
de: Fehler bei der Analyse der Felder

en: error while parsing final attributes
de: Fehler beim Analysieren der final-Attribute

en: error while parsing final attributes
de: Fehler beim Analysieren der final-Attribute

en: error while parsing methods
de: Fehler beim Analysieren der Methoden

en: error while parsing methods
de: Fehler beim Analysieren der Methoden

en: error while reading %s from zip file
de: Fehler beim Lesen von %s aus ZIP-Datei

en: error writing %qs
de: Fehler beim Schreiben von %qs

en: error writing to %s: %m
de: Fehler beim Schreiben der Datei %s: %m

en: error:
de: Fehler:

en: exception handling disabled, use -fexceptions to enable
de: Ausnahmebehandlung ausgeschaltet, benutzen Sie -fexeptions zum Einschalten

en: exception of type %<%T%> will be caught
de: Ausnahme des Typs %<%T%> wird gefangen werden

en: exception of type %qT will be caught
de: Ausnahme des Typs %qT wird gefangen werden

en: excess elements in array initializer
de: Elementüberschreitung in Feldinitialisierung

en: excess elements in char array initializer
de: Elementüberschreitung in char-Feld-Initialisierung

en: excess elements in scalar initializer
de: Elementüberschreitung in Skalarinitialisierung

en: excess elements in struct initializer
de: Elementüberschreitung in struct-Initialisierung

en: excess elements in union initializer
de: Elementüberschreitung in union-Initialisierung

en: excess elements in vector initializer
de: Elementüberschreitung in Vektorinitialisierung

en: execution count is negative
de: Ausführungszähler ist negativ

en: execution counts assumed to be zero
de: Ausführungszähler als null angenommen

en: execution counts estimated
de: Ausführungszähler voraussichtlich

en: exit %d->%d not recorded
de: Ausgang %d->%d nicht aufgezeichnet

en: expand_binop failed in movsi got
de: expand_binop in movsi got gescheitert

en: expansion pattern %<%E%> contains no argument packs
de: Auflösungsmuster %<%E%> enthält keine Argumentpacks

en: expansion pattern %<%T%> contains no argument packs
de: Auflösungsmuster %<%T%> enthält keine Argumentpacks

en: expected %<#pragma omp section%> or %<}%>
de: %<#pragma omp section%> oder %<}%> erwartet

en: expected %<#pragma omp%> clause
de: Klausel %<#pragma omp%> erwartet

en: expected %<(%>
de: %<(%> erwartet

en: expected %<(%> or end of line
de: %<(%> oder Zeilenende erwartet

en: expected %<)%>
de: %<)%> erwartet

en: expected %<*%>
de: %<*%> erwartet

en: expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, or %<||%>
de: %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%> oder %<||%> erwartet

en: expected %<,%>
de: %<,%> erwartet

en: expected %<,%> or %<)%>
de: %<,%> oder %<)%> erwartet

en: expected %<,%> or %<...%>
de: %<,%> oder %<...%> erwartet

en: expected %<,%> or %<;%>
de: %<,%> oder %<;%> erwartet

en: expected %<,%> or %<}%>
de: %<,%> oder %<}%> erwartet

en: expected %<,%>, %<;%> or %<}%>
de: %<,%>, %<;%> oder %<}%> erwartet

en: expected %<.%>
de: %<.%> erwartet

en: expected %<...%>
de: %<...%> erwartet

en: expected %<:%>
de: %<:%> erwartet

en: expected %<:%> or %<...%>
de: %<:%> oder %<...%> erwartet

en: expected %<:%> or %<::%>
de: %<:%> oder %<::%> erwartet

en: expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>
de: %<:%>, %<,%>, %<;%>, %<}%> oder %<__attribute__%> erwartet

en: expected %<::%>
de: %<::%> erwartet

en: expected %<;%>
de: %<;%> erwartet

en: expected %<;%> after class definition
de: %<;%> hinter Klassendefinition erwartet

en: expected %<;%> after struct definition
de: %<;%> hinter Strukturdefinition erwartet

en: expected %<;%> after union definition
de: %<;%> hinter Uniondefinition erwartet

en: expected %<;%> at end of member declaration
de: %<;%> am Ende von Elementdeklaration erwartet

en: expected %<;%> or %<{%>
de: %<;%> oder %<{%> erwartet

en: expected %<;%> or %<{%> after method attribute definition
de: %<;%> or %<{%> nach Definition der Methodenattribute erwartet

en: expected %<;%>, %<,%> or %<)%>
de: %<;%>, %<,%> oder %<)%> erwartet

en: expected %<;%>, identifier or %<(%>
de: %<;%>, Bezeichner oder %<(%> erwartet

en: expected %<<%>
de: %<%> erwartet

en: expected %<=%>
de: %<=%> erwartet

en: expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>
de:  %<=%>, %<,%>, %<;%>, %<asm%> oder %<__attribute__%> erwartet

en: expected %<>%>
de: %<>%> erwartet

en: expected %<@end%>
de: %<@end%> erwartet

en: expected %<@synchronized%>
de: %<@synchronized%> erwartet

en: expected %<@throw%>
de: %<@throw%> erwartet

en: expected %<@try%>
de: %<@try%> erwartet

en: expected %<[%>
de: %<[%> erwartet

en: expected %<]%>
de: %<]%> erwartet

en: expected %<__label__%>
de: %<__label__%> erwartet

en: expected %<asm%>
de: %<asm%> erwartet

en: expected %<catch%>
de: %<catch%> erwartet

en: expected %<class%>
de: %<class%> erwartet

en: expected %<class%>, %<typename%>, or %<template%>
de: %<class%>, %<typename%> oder %<template%> erwartet

en: expected %<decltype%>
de: %<decltype%> erwartet

en: expected %<delete%>
de: %<delete%> erwartet

en: expected %<extern%>
de: %<extern%> erwartet

en: expected %<namespace%>
de: %<namespace%> erwartet

en: expected %<new%>
de: %<new%> erwartet

en: expected %<none%> or %<shared%>
de: %<none%> oder %<shared%> erwartet

en: expected %<operator%>
de: %<operator%> erwartet

en: expected %<return%>
de: %<return%> erwartet

en: expected %<static_assert%>
de: %<static_assert%> erwartet

en: expected %<template%>
de: %<template%> erwartet

en: expected %<throw%>
de: %<throw%> erwartet

en: expected %<try%>
de: %<try%> erwartet

en: expected %<using%>
de: %<using%> erwartet

en: expected %<while%>
de: %<while%> erwartet

en: expected %<{%>
de: %<{%> erwartet

en: expected %<{%> or %<:%>
de: %<{%> oder %<:%> erwartet

en: expected %<}%>
de: %<}%> erwartet

en: expected %<}%> before %<else%>
de: %<}%> vor %<else%> erwartet

en: expected %<~%>
de: %<~%> erwartet

en: expected %d levels of template parms for %q#D, got %d
de: %d Ebenen von Template-Parametern für %q#D erwartet, %d erhalten

en: expected %qT but argument is of type %qT
de: %qT erwartet, aber Argument hat Typ %qT

en: expected [error|warning|ignored|push|pop] after %<#pragma GCC diagnostic%>
de: [error|warning|ignored|push|pop] nach %<#pragma GCC diagnostic%> erwartet

en: expected a string after %<#pragma message%>
de: hinter %<#pragma message%> wird eine Zeichenkette erwartet

en: expected an SSA_NAME object
de: SSA_NAME-Objekt erwartet

en: expected boolean expression
de: boolscher Ausdruck erwartet

en: expected channel
de: Kanal erwartet

en: expected class name
de: Klassenname erwartet

en: expected class-key
de: Klassenschlüssel erwartet

en: expected class-name
de: Klassenname erwartet

en: expected constructor, destructor, or type conversion
de: Konstruktor, Destruktor oder Typumwandlung erwartet

en: expected declaration
de: Deklaration erwartet

en: expected declaration or statement
de: Deklaration oder Anweisung erwartet

en: expected declaration specifiers
de: Deklarationsspezifizierer erwartet

en: expected declaration specifiers or %<...%>
de: Deklarationsspezifizierer oder %<...%> erwartet

en: expected declarator
de: Deklarator erwartet

en: expected end of capture-list
de: unerwartetes Ende der Auffangliste

en: expected end of line
de: Zeilenende erwartet

en: expected expression
de: Ausdruck erwartet

en: expected function
de: Funktion erwartet

en: expected id-expression
de: ID-Ausdruck erwartet

en: expected identifier
de: Bezeichner erwartet

en: expected identifier or %<(%>
de: Bezeichner oder %<(%> erwartet

en: expected identifier or %<)%>
de: Bezeichner oder %<)%> erwartet

en: expected identifier or %<*%>
de: Bezeichner oder %<*%> erwartet

en: expected initializer
de: Initialisierung erwartet

en: expected integer expression
de: Ganzzahlausdruck erwartet

en: expected integer or boolean type
de: Ganzzahlausdruck oder boolscher Typ erwartet

en: expected interface or pointer to interface
de: Schnittstelle oder Zeiger auf Schnittstelle erwartet

en: expected iteration declaration or initialization
de: Schleifendeklaration oder Initialisierung erwartet

en: expected iteration-statement
de: Iterationsanweisung erwartet

en: expected jump-statement
de: Sprunganweisung erwartet

en: expected labeled-statement
de: benannte Anweisung erwartet

en: expected map index on left hand side
de: Abbildungsindex auf linker Seite erwartet

en: expected map index on right hand side
de: Abbildungsindex auf rechter Seite erwartet

en: expected namespace-name
de: Namensraumname erwartet

en: expected nested-name-specifier
de: Spezifikation mit geschachteltem Namen erwartet

en: expected numeric type
de: numerischer Typ erwartet

en: expected operator
de: Operator erwartet

en: expected parameter pack before %<...%>
de: Parameterbündel vor %<...%> erwartet

en: expected pointer
de: Zeiger erwartet

en: expected primary-expression
de: übergeordneter Ausdruck erwartet

en: expected ptr-operator
de: Ptr-Operator erwartet

en: expected qualified name in friend declaration for constructor %qD
de: Qualifizierten Namen in Friend-Deklaration für Konstruktor %qD erwartet

en: expected qualified name in friend declaration for destructor %qD
de: Qualifizierten Namen in Friend-Deklaration für Destruktor %qD erwartet

en: expected selection-statement
de: Auswahl-Anweisung erwartet

en: expected specifier-qualifier-list
de: Spezifizierer-Qualifizierer-Liste erwartet

en: expected statement
de: Anweisung erwartet

en: expected string literal
de: Zeichenkettenliteral erwartet

en: expected string-literal
de: Zeichenkettenliteral erwartet

en: expected template-argument
de: Templateargument erwartet

en: expected template-id
de: Template-ID erwartet

en: expected template-id for type
de: Template-ID für Typ erwartet

en: expected template-name
de: Templatename erwartet

en: expected type specifier
de: Typspezifizierer erwartet

en: expected type-name
de: Typ-Name erwartet

en: expected type-specifier
de: Typspezifikation erwartet

en: expected unqualified-id
de: unqualifiziertes ID erwartet

en: explicit conversion operators only available with -std=c++0x or -std=gnu++0x
de: explizite Umwandlungsoperatoren nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: explicit goto at end of bb %d
de: Explizites Goto am Ende von bb %d

en: explicit instantiation of %q#D
de: explizite Instanziierung von %q#D

en: explicit instantiation of %q#T before definition of template
de: explizite Instanziierung von %q#T vor Definition des Templates

en: explicit instantiation of %qD but no definition available
de: explizite Instanziierung von %qD, aber keine Definition verfügbar

en: explicit instantiation of %qD in namespace %qD (which does not enclose namespace %qD)
de: explizite Instantiierung von %qD in Namensbereich %qD (das nicht Namensbereich %qD einschließt)

en: explicit instantiation of non-template %q#D
de: explizite Instanziierung des Nicht-Templates %q#D

en: explicit instantiation of non-template type %qT
de: explizite Instanziierung des Nicht-Templatetyps %qT

en: explicit instantiation shall not use %<constexpr%> specifier
de: explizite Instanziierung sollte nicht %<constexpr%> verwenden

en: explicit instantiation shall not use %<inline%> specifier
de: explizite Instanziierung sollte nicht %<inline%> verwenden

en: explicit qualification in declaration of %qD
de: explizite Qualifizierung in Deklaration von %qD

en: explicit specialization in non-namespace scope %qD
de: explizite Spezialisierung in Gültigkeitsbereich des Nicht-Namensbereiches %qD

en: explicit specialization of %qD after first use
de: explizite Spezialisierung von %qD nach erster Benutzung

en: explicit specialization of %qD must be introduced by %<template <>%>
de: der expliziten Spezialisierung von %D muss %<template <>%> vorausgehen

en: explicit specialization of non-template %qT
de: explizite Spezialisierung des Nicht-Templates %qT

en: explicit template argument list not allowed
de: explizite Templateargumentliste nicht erlaubt

en: explicit template specialization cannot have a storage class
de: explizite Template-Spezialisierung kann keine Speicherklasse haben

en: expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L
de: Ausdruck in Zuweisung !$OMP ATOMIC »var = var op expr« muss skalar sein und kann keine Variable bei %L referenzieren

en: expression %qE does not designate a constexpr function
de: Ausdruck %qE bezeichnet keine Funktion mit konstantem Ausdruck

en: expression %qE has side-effects
de: Ausdruck %qE hat Seiteneffekte

en: expression %qE is not a constant-expression
de: Ausdruck %qE ist kein konstanter Ausdruck

en: expression %qE of abstract class type %qT cannot be used in throw-expression
de: Ausdruck %qE von abstraktem Klassentyp %qT kann nicht in throw-Ausdruck verwendet werden

en: expression in new-declarator must have integral or enumeration type
de: Ausdruck in new-Deklarator muss Ganzzahl- oder Aufzählungstyp haben

en: expression in static assertion is not an integer
de: Ausdruck in statischer Behauptung ist keine Ganzzahl

en: expression in static assertion is not an integer constant expression
de: Ausdruck in statischer Behauptung ist kein konstanter Ganzzahlausdruck

en: expression in static assertion is not constant
de: Ausdruck in statischer Behauptung ist nicht konstant

en: expression list treated as compound expression in functional cast
de: Ausdrucksliste als zusammengesetzten Ausdruck in funktionaler Umwandlung behandelt

en: expression list treated as compound expression in initializer
de: Ausdrucksliste als zusammengesetzten Ausdruck in Initialisierung behandelt

en: expression list treated as compound expression in mem-initializer
de: Ausdrucksliste als zusammengesetzten Ausdruck in Speicherinitialisierung behandelt

en: expression statement has incomplete type
de: Ausdrucksanweisung hat unvollständigen Typ

en: extended initializer lists only available with -std=c++0x or -std=gnu++0x
de: erweiterte Initialisierungsliste nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: extended registers have no high halves
de: erweiterte Register haben keine oberen Hälften

en: extern declaration of %q#D doesn%'t match
de: externe Deklaration von %q#D passt nicht

en: extern declaration of %q+D follows declaration with no linkage
de: extern-Deklaration von %q+D folgt Deklaration ohne Bindung

en: external linkage required for symbol %q+D because of %qE attribute
de: für Symbol %q+D wird wegen des Attributes %qE externe Bindung benötigt

en: externally visible inline clone
de: extern sichtbare Inline-Kopie

en: extra %<;%>
de: zusätzliches %<;%>

en: extra brace group at end of initializer
de: zusätzliche geschweifte Klammern am Ende der Initialisierung

en: extra elements in scalar initializer
de: zusätzliche Elemente in Skalar-Initialisierung

en: extra outgoing edge %d->%d
de: Zusätzliche ausgehende Kante %d->%d

en: extra qualification %<%T::%> on member %qs
de: zusätzliche Qualifizierung %<%T::%> an Element %qs

en: extra qualification not allowed
de: zusätzliche Qualifizierung nicht erlaubt

en: extra semicolon in method definition specified
de: zusätzliches Semikolon in Methodendefinition angegeben

en: extra semicolon in struct or union specified
de: zusätzliches Semikolon in »struct« oder »union« angegeben

en: extra type qualifiers in format argument (argument %d)
de: zusätzliche Typqualifizierer in Format-Argument (Argument %d)

en: fail to initialize plugin %s
de: Plugin %s kann nicht initialisiert werden

en: failed to close read state file %s [%s]
de: Gelesene Zustandsdatei %s [%s] konnte nicht geschlossen werden

en: failed to close state file %s [%s]
de: Zustandsdatei %s [%s] konnte nicht geschlossen werden

en: failed to find class '%s'
de: Suche nach Klasse »%s« gescheitert

en: failed to get exit status: %m
de: Ende-Status konnte nicht ermittelt werden: %m

en: failed to get process times: %m
de: Verarbeitungszeiten konnten nicht ermittelt werden: %m

en: failed to open %s
de: »%s« kann nicht geöffnet werden

en: failed to open temporary file %s for LTO output
de: temporäre Datei %s konnte nicht für LTO-Ausgaben geöffnet werden

en: failed to open temporary file %s with LTO output
de: temporäre Datei %s konnte nicht mit LTO-Ausgabe geöffnet werden

en: failed to reclaim unneeded function
de: Zurückfordern der nicht genötigten Funktion gescheitert

en: failed to rename %s to state file %s [%s]
de: %s konnte nicht in Zustandsdatei %s [%s] umbenannt werden

en: failed to write state trailer [%s]
de: Zustandssuffix [%s] konnte nicht geschrieben werden

en: failure in redeclaration of %q+D: dllimport%'d symbol lacks external linkage
de: Fehler in Redeklaration von %q+D: »dllimport«-iertem Symbol fehlt externe Bindung

en: failure to simplify substring reference in DATA statement at %L
de: Fehlschlag bei Vereinfachung der Teil-Zeichenketten-Referenz in DATA-Anweisung bei %L

en: failure trying to reload:
de: Neuladen gescheitert:

en: fallthru edge after a control statement in bb %d
de: Fallthru-Kante hinter einer Kontrollanweisung in bb %d

en: fallthru edge after unconditional jump %i
de: Fallthru-Kante nach unbedingtem Sprung %i

en: fallthru edge crosses section boundary (bb %i)
de: Fall-Through-Kante überschreitet Abschnittsgrenze (bb %i)

en: fallthru to exit from bb %d
de: Fallthru zum Austritt von bb %d

en: fast enumeration is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine schnelle Aufzählung

en: fastcall and cdecl attributes are not compatible
de: Attribute fastcall und cdecl sind nicht verträglich

en: fastcall and regparm attributes are not compatible
de: Attribute fastcall und regparm sind nicht verträglich

en: fastcall and stdcall attributes are not compatible
de: Attribute fastcall und stdcall sind nicht verträglich

en: fastcall and thiscall attributes are not compatible
de: Attribute fastcall und thiscall sind nicht verträglich

en: fatal error:
de: schwerwiegender Fehler:

en: field %q+#D with same name as class
de: Feld %q+#D mit gleichem Namen wie Klasse

en: field %q+D invalidly declared function type
de: Feld %q+D deklarierte ungültigerweise einen Funktionstypen

en: field %q+D invalidly declared method type
de: Feld %q+D deklarierte ungültigerweise einen Methodentypen

en: field %qD has incomplete type
de: Feld %qD hat unvollständigen Typen

en: field %qE declared as a function
de: Feld %qE als Funktion deklariert

en: field %qE has incomplete type
de: Feld %qE hat unvollständigen Typen

en: field %qs not found
de: Feld %qs nicht gefunden

en: field in mismatching type declared here
de: Feld in unpassendem Typen hier deklariert

en: field initializer is not constant
de: Feldinitialisierung ist nicht konstant

en: field name not in record or union initializer
de: Feldname nicht in Datensatz- oder union-Initialisierung

en: field precision specifier
de: Feldpräzisionsangabe

en: field width
de: Feldbreite

en: field width in printf format
de: Feldbreite im printf-Format

en: field width in scanf format
de: Feldbreite im scanf-Format

en: field width in strfmon format
de: Feldbreite im strfmon-Format

en: field width in strftime format
de: Feldbreite im strftime-Format

en: field width specifier
de: Feldbreitenangabe

en: file ends in default argument
de: Datei endet in Standardargument

en: file-scope declaration of %qE specifies %<auto%>
de: Deklaration von %qE in Datei-Sichtbarkeitsbereich spezifiziert %<auto%>

en: file-scope declaration of %qE specifies %<register%>
de: Deklaration von %qE in Datei-Sichtbarkeitsbereich spezifiziert %<register%>

en: fill character
de: Füllzeichen

en: fill character in strfmon format
de: Füllzeichen im strfmon-Format

en: find_enum(): Enum not found
de: find_enum(): Enum nicht gefunden

en: fini function found in object %s
de: fini-Funktion im Objekt %s gefunden

en: first argument of %q+D should be %<int%>
de: erstes Argument von %q+D sollte %<int%> sein

en: first argument to %<__builtin_choose_expr%> not a constant
de: erstes Argument für %<__builtin_choose_expr%> ist keine Konstante

en: first argument to %<va_arg%> not of type %<va_list%>
de: Erstes Argument für %<va_arg%> nicht vom Typ %<va_list%>

en: fixed-point overflow in expression
de: Festkommaüberlauf in Ausdruck

en: fixed-point types not supported for this target
de: Festkommatypen werden für dieses Ziel nicht unterstützt

en: fixed-point types not supported in C++
de: Festkommatypen werden in C++ nicht unterstützt

en: flexible array member in otherwise empty struct
de: flexibles Feld-Element in ansonsten leerem struct

en: flexible array member in union
de: flexibles Feldelement in Union

en: flexible array member not at end of struct
de: flexibles Feld-Element nicht am Ende von struct

en: floating constant exceeds range of %qT
de: Gleitkommakonstante überschreitet Wertebereich von %qT

en: floating constant misused
de: Gleitkommakonstante falsch benutzt

en: floating constant truncated to zero
de: Gleitkommakonstante auf Null abgeschnitten

en: floating point constant not a valid immediate operand
de: Gleitkommakonstante ist kein gültiger direkter Operand

en: floating point constant truncated to integer
de: Gleitkommakonstante auf Ganzzahl abgeschnitten

en: floating point overflow in expression
de: Gleitkommaüberlauf in Ausdruck

en: floating-point literal cannot appear in a constant-expression
de: Gleitkommaliteral kann nicht in einem Konstanten-Ausdruck auftreten

en: flow control insn inside a basic block
de: Flusskontrollbefehl innerhalb eines Basis-Blockes

en: fold check: original tree changed by fold
de: Faltungstest: ursprünglicher Baum durch Faltung geändert

en: follows non-prototype definition here
de: folgt Nicht-Prototyp-Definition hier

en: for increment expression cannot resolve address of overloaded function
de: Erhöhungsausdruck kann die Adresse der überladenen Funktion nicht auflösen

en: for increment expression has no effect
de: Erhöhungsausdruck hat keinen Effekt

en: for increment expression is a reference, not call, to function %qE
de: Erhöhungsausdruck ist eine Referenz, kein Aufruf, zur Funktion %qE

en: for statement expected
de: für Anweisung erwartet

en: for template declaration %q+D
de: Für Template-Deklaration %q+D

en: format
de: Format

en: format argument %d unused before used argument %d in $-style format
de: Formatargument %d nicht verwendet vor benutztem Argument %d im $-Stil-Format

en: format argument %d used more than once in %s format
de: Formatargument %d mehr als einmal im %s-Format verwendet

en: format argument should be a %<%s%> reference
de: Formatargument sollte eine %<%s%>-Referenz sein

en: format argument should be a %<%s%> reference but a string was found
de: Formatargument sollte eine %<%s%>-Referenz sein, aber eine Zeichenkette wurde gefunden

en: format is a wide character string
de: Format ist »wide character«-Zeichenkette

en: format not a string literal and no format arguments
de: Format ist kein Zeichenkettenliteral, und keine Formatargumente

en: format not a string literal, argument types not checked
de: Format ist kein Zeichenkettenliteral, Argumenttypen ungeprüft

en: format not a string literal, format string not checked
de: Format ist kein Zeichenkettenliteral, Formatzeichenkette ungeprüft

en: format string argument follows the args to be formatted
de: Format-Zeichenkettenargument folgt den zu formatierenden Argumenten

en: format string argument is not a string type
de: Format-Zeichenkettenargument ist kein Zeichenkettentyp

en: format string has invalid operand number
de: Formatzeichenkette hat ungültige Operandenzahl

en: forming pointer to reference type %qT
de: Zeiger auf Referenztyp %qT wird geformt

en: forming reference to reference type %qT
de: Referenz auf Referenztyp %qT wird geformt

en: forming reference to void
de: Referenz auf »void« wird gebildet

en: forward declaration of %q+#T
de: Vorwärtsdeklaration von %q+#T

en: found %<%c%s%>
de: %<%c%s%> gefunden

en: found %<-%E%> instead of %<+%E%> in protocol(s)
de: %<-%E%> statt %<+%E%> in Protokoll(en) gefunden

en: found %<:%> in nested-name-specifier, expected %<::%>
de: %<:%> in Spezifikation mit geschachteltem Namen gefunden, %<::%> erwartet

en: found a %<%s%> reference but the format argument should be a string
de: eine %<%s%>-Referenz wurde gefunden, aber das Format-Argument sollte eine Zeichenkette sein

en: found a %qT but the format argument should be a string
de: ein %qT wurde gefunden, aber das Format-Argument sollte eine Zeichenkette sein

en: found a default name with a non-empty defining statement
de: Standardname mit nichtleerer Definitionsanweisung gefunden

en: found a real definition for a non-register
de: reale Definition für Nicht-Register gefunden

en: found a virtual definition for a GIMPLE register
de: virtuelle Definition für ein GIMPLE-Register gefunden

en: found an SSA_NAME that had been released into the free pool
de: SSA_NAME gefunden, das bereits in den Frei-Bereich geschoben wurde

en: found default case not at the start of case vector
de: Standard-Fall nicht am Anfang des case-Vektors gefunden

en: fp software completion requires -mtrap-precision=i
de: FP-Software-Vervollständigung benötigt -mtrap-precision=i

en: fr30_print_operand: invalid %%F code
de: fr30_print_operand: ungültiger Code %%F

en: fr30_print_operand: invalid %%x code
de: fr30_print_operand: ungültiger Code %%x

en: fr30_print_operand: invalid operand to %%A code
de: fr30_print_operand: ungültiger Operand für Code %%A

en: fr30_print_operand: unhandled MEM
de: fr30_print_operand: unbehandeltes MEM

en: fr30_print_operand: unknown code
de: fr30_print_operand: unbekannter Code

en: fr30_print_operand: unrecognized %%B code
de: fr30_print_operand: nicht erkannter Code %%B

en: fr30_print_operand: unrecognized %%b code
de: fr30_print_operand: nicht erkannter Code %%b

en: fr30_print_operand: unrecognized %%p code
de: fr30_print_operand: nicht erkannter Code %%p

en: fr30_print_operand_address: unhandled address
de: fr30_print_operand_address: unbehandelte Adresse

en: frame size of %qs is
de: Rahmengröße von %qs ist

en: frame size of function %qs is
de: Rahmengröße der Funktion %qs ist

en: frame size too large for reliable stack checking
de: Rahmengröße zu groß für zuverlässige Kellerüberprüfung

en: friend declaration %q#D declares a non-template function
de: »friend«-Deklaration %q#D deklariert eine Nicht-Template-Funktion

en: friend declaration %qD in local class without prior declaration
de: Friend-Deklaration %qD in lokaler Klasse ohne vorherige Deklaration

en: friend declaration does not name a class or function
de: »friend«-Deklaration benennt keine Klasse oder Funktion

en: friend declaration not in class definition
de: friend-Deklaration nicht in Klassendefinition

en: friend declaration requires class-key, i.e. %<friend %#T%>
de: friend-Deklaration erfordert Klassenschlüssel, d.h. %<friend %#T%>

en: friend declaration requires class-key, i.e. %<friend class %T::%D%>
de: friend-Deklaration erfordert Klassenschlüssel, d.h. %<friend class %T::%D%>

en: from previous declaration %q+D
de: von vorheriger Deklaration %q+D

en: from previous declaration %q+F
de: von vorheriger Deklaration %q+F

en: from this location
de: von dieser Stelle

en: frv_print_operand: unknown code
de: frv_print_operand: unbekannter Code

en: function %q#D is initialized like a variable
de: Funktion %q#D ist wie eine Variable initialisiert

en: function %q+D defaulted on its first declaration must not have an exception-specification
de: bei ihrer ersten Deklaration vorgegebene Funktion %q+D darf keine Ausnahmespezifikation haben

en: function %q+D definition is marked dllimport
de: Funktionsdefinition von %q+D ist als »dllimport« markiert

en: function %q+D is defined after prior declaration as dllimport: attribute ignored
de: Funktion %q+D wurde nach vorheriger Deklaration als »dllimport« definiert: Attribut ignoriert

en: function %q+D redeclared as inline
de: Funktion %q+D als inline redeklariert

en: function %q+D redeclared with attribute noinline
de: Funktion %q+D mit Attribut noinline redeklariert

en: function %q+F can never be copied because it receives a non-local goto
de: Funktion %q+F kann nie kopiert werden, da sie ein nichtlokales »goto« empfängt

en: function %q+F can never be copied because it saves address of local label in a static variable
de: Funktion %q+F kann nie kopiert werden, da sie die Adresse einer lokalen Marke in statischer Variablen speichert

en: function %q+F can never be inlined because it contains a computed goto
de: die Funktion %q+F kann nie »inline« sein, da sie ein berechnetes »goto« enthält

en: function %q+F can never be inlined because it is suppressed using -fno-inline
de: Funktion %q+F kann nie inline sein, da dies mit -fno-inline unterdrückt wird

en: function %q+F can never be inlined because it uses __builtin_return or __builtin_apply_args
de: die Funktion %q+F kann nie »inline« sein, da sie __builtin_return oder __builtin_apply_args verwendet

en: function %q+F can never be inlined because it uses alloca (override using the always_inline attribute)
de: die Funktion %q+F kann nie »inline« sein, da sie alloca verwendet (zum Aufheben: Attribut »always_inline« verwenden)

en: function %q+F can never be inlined because it uses attributes conflicting with inlining
de: Funktion %q+F kann nie inline sein, da sie mit inline in Konflikt stehende Attribute hat

en: function %q+F can never be inlined because it uses non-local goto
de: die Funktion %q+F kann nie »inline« sein, da sie ein nichtlokales »goto« enthält

en: function %q+F can never be inlined because it uses setjmp
de: die Funktion %q+F kann nie »inline« sein, da sie setjmp verwendet

en: function %q+F can never be inlined because it uses setjmp-longjmp exception handling
de: die Funktion %q+F kann nie »inline« sein, da sie »setjmp-longjmp«-Ausnahmebehandlung verwendet

en: function %q+F can never be inlined because it uses variable argument lists
de: die Funktion %q+F kann nie »inline« sein, da sie eine variable Argumentliste verwendet

en: function %qD declared virtual inside a union
de: Funktion %qD als virtuell innerhalb einer Union deklariert

en: function %qD is initialized like a variable
de: Funktion %qD ist wie eine Variable initialisiert

en: function %qD redeclared as variable
de: Funktion %qD als Variable redeklariert

en: function %qD used as %<asm%> output
de: Funktion %qD als %<asm%>-Ausgabe verwendet

en: function %qs cannot be declared %<mutable%>
de: Funktion %qs kann nicht als %<mutable%> deklariert sein

en: function body can be overwriten at linktime
de: Funktionskörper kann zum Link-Zeitpunkt überschrieben werden

en: function body not available
de: Funktionskörper nicht verfügbar

en: function call has aggregate value
de: Funktionsaufruf hat zusammengesetzten Wert

en: function called through a non-compatible type
de: Funktion über nicht kompatiblen Typen aufgerufen

en: function declaration isn%'t a prototype
de: Funktionsdeklaration ist kein Prototyp

en: function declared %<noreturn%> has a %<return%> statement
de: als %<noreturn%> deklarierte Funktion hat %<return%>-Anweisung

en: function definition declared %<__thread%>
de: Funktionsdefinition deklarierte %<__thread%>

en: function definition declared %<auto%>
de: Funktionsdefinition deklarierte %<auto%>

en: function definition declared %<register%>
de: Funktionsdefinition deklarierte %<register%>

en: function definition declared %<typedef%>
de: Funktionsdefinition deklarierte %<typedef%>

en: function definition does not declare parameters
de: Funktionsdefinition deklariert keine Parameter

en: function definition has qualified void return type
de: Funktionsdefinition hat qualifizierten void-Rückgabetypen

en: function does not return string type
de: Funktion gibt keinen Zeichenkettentypen zurück

en: function might be candidate for attribute %<%s%>
de: Funktion könnte Kandidat für Attribut %<%s%> sein

en: function might be candidate for attribute %<%s%> if it is known to return normally
de: Funktion könnte Kandidat für Attribut %<%s%> sein, wenn sie als normal zurückkehrend bekannt ist

en: function might be possible candidate for %qs format attribute
de: Funktion könnte möglicher Kandidat für Formatattribut %qs sein

en: function not considered for inlining
de: Funktion kommt nicht für »inline« in Betracht

en: function not declared inline and code size would grow
de: Funktion nicht »inline« deklariert und Codegröße würde wachsen

en: function not inlinable
de: Funktion kann nicht »inline« sein

en: function not inline candidate
de: Funktion kein Kandidat für »inline«

en: function parameters cannot have __fp16 type
de: Funktionsparameter können nicht Typ __fp16 haben

en: function return type cannot be function
de: Rückgabetyp der Funktion kann keine Funktion sein

en: function return types not compatible due to %<volatile%>
de: Funktionsrückgabetypen nicht kompatibel wegen %<volatile%>

en: function returning a function
de: Funktion gibt eine Funktion

en: function returning an array
de: Funktion gibt ein Feld zurück

en: function returns address of local variable
de: Funktion liefert Adresse einer lokalen Variablen zurück

en: function returns an aggregate
de: Funktion gibt Aggregat zurück

en: function template %qD redeclared as a class template
de: Funktions-Template %qD als Klassentemplate redeklariert

en: function template partial specialization %qD is not allowed
de: Teilspezialisierung %qD des Funktionstemplates ist nicht erlaubt

en: function types not truly compatible in ISO C
de: Funktionstypen nicht wirklich kompatibel in ISO-C

en: function with qualified void return type called
de: Funktion mit qualifiziertem void-Rückgabetypen aufgerufen

en: function-scope %qE implicitly auto and declared %<__thread%>
de: Funktions-Gültigkeitsbereich %qE ist implizit auto und als %<__thread%> deklariert

en: function-scope %qs implicitly auto and declared %<__thread%>
de: Funktions-Gültigkeitsbereich %qs ist implizit auto und deklarierte %<__thread%>

en: function_profiler support
de: function_profiler-Unterstützung

en: function_profiler support for MMIX
de: function_profiler-Unterstützung für MMIX

en: functions cannot return __fp16 type
de: Funktionen können nicht Typ __fp16 zurückgeben

en: gcc driver version %s %sexecuting gcc version %s
de: gcc-Treiberversion %s %s führt GCC-Version %s aus

en: gcc version %s %s
de: gcc-Version %s %s

en: generic CPU can be used only for %stune=%s %s
de: generische CPU kann nur für %stune=%s %s verwendet werden

en: generic thunk code fails for method %q#D which uses %<...%>
de: allgemeiner Thunk-Code für Methode %q#D mit %<...%> scheitert

en: getting core file size maximum limit: %m
de: Kern-Dateigrößenlimit wird geholt: %m

en: gfc_conv_constant_to_tree(): invalid type: %s
de: gfc_conv_constant_to_tree(): ungültiger Typ: %s

en: gfc_trans_code(): Bad statement code
de: gfc_trans_code(): Falscher Anweisungscode

en: gfortran does not support -E without -cpp
de: gfortran unterstützt nicht -E ohne -cpp

en: gimple bytecode streams do not support machine specific builtin functions on this target
de: GIMPLE-Bytecode-Ströme unterstützen keine maschinenspezifischen eingebauten Funktionen auf diesem Ziel

en: gimple bytecode streams do not support the optimization attribute
de: GIMPLE-Bytecode-Ströme unterstützen nicht das Optimierungsattribut

en: gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d
de: GIMPLE-Prüfung: %s(%s) erwartet, haben %s(%s) in %s, bei %s:%d

en: gimple_bb (phi) is set to a wrong basic block
de: gimple_bb (phi) wird auf falschen Basisblock gesetzt

en: gimple_bb (stmt) is set to a wrong basic block
de: gimple_bb (stmt) ist auf falschen Basisblock gesetzt

en: gimplification failed
de: Gimplifikation gescheitert

en: global constructors not supported on this target
de: globale Konstruktoren werden für dieses Ziel nicht unterstützt

en: global declaration %q+#D
de: globale Deklaration von %q+#D

en: global destructors not supported on this target
de: globale Destruktoren werden für dieses Ziel nicht unterstützt

en: global qualification of class name is invalid
de: globale Qualifizierung von Klassenname ist ungültig

en: global register variable %qD used in nested function
de: globale Register-Variable %qD in verschachtelter Funktion verwendet

en: global register variable follows a function definition
de: globale Registervariable folgt einer Funktionsdefinition

en: global register variable has initial value
de: globale Registervariable hat Anfangswert

en: global/static variable assignment has been intercepted
de: Globale/statische Variablenzuweisung wurde abgefangen

en: got %d template parameters for %q#D
de: %d Template-Parameter für %q#D erhalten

en: got %d template parameters for %q#T
de: %d Template-Parameter für %q#T erhalten

en: goto destination is neither a label nor a pointer
de: Goto-Ziel ist weder eine Marke noch ein Zeiger

en: gp is constant (but save/restore gp on indirect calls)
de: gp ist konstant (aber gp wird bei indirekten Aufrufen gesichert/wiederhergestellt)

en: gp_offset (%ld) or end_offset (%ld) is less than zero
de: gp_offset (%ld) oder end_offset (%ld) ist kleiner als Null

en: had to relocate PCH
de: PCH musste verschoben werden

en: hard-float MIPS16 code for ABIs other than o32 and o64
de: Hardware-Gleitkommacode für MIPS16 für ABIs außer o32 und o64

en: hardware decimal floating point instructions not available in ESA/390 mode
de: Dezimale Hardware-Gleitkomma-Befehle sind im ESA/390-Modus nicht verfügbar

en: hardware decimal floating point instructions not available on %s
de: Dezimale Hardware-Gleitkomma-Befehle sind auf %s nicht verfügbar

en: head insn %d for block %d not found in the insn stream
de: Kopf-Befehl %d für Block %d nicht im Befehlsstrom gefunden

en: iWMMXt and hardware floating point
de: iWMMXt und Hardware-Gleitkomma

en: ia64_print_operand: unknown code
de: ia64_print_operand: unbekannter Code

en: identifier %qE conflicts with C++ keyword
de: Bezeichner %qE steht mit C++-Schlüsselwort in Konflikt

en: identifier %qE will become a keyword in C++0x
de: Bezeichner %qE wird in C++0x zum Schlüsselwort

en: identifier expected after %<@protocol%>
de: Bezeichner nach %<@protocol%> erwartet

en: if this code is reached, the program will abort
de: Wenn dieser Code erreicht wird, wird das Programm abgebrochen

en: ifunc is not supported in this configuration
de: ifunc wird in dieser Konfiguration nicht unterstützt

en: ignoring #pragma %s %s
de: #pragma %s %s wird ignoriert

en: ignoring %<#pragma align%> for explicitly aligned %q+D
de: %<#pragma align%> wird für explizit ausgerichtetes %q+D ignoriert

en: ignoring -fschedule-insns because of exception handling bug
de: -fschedule-insns wird wegen Ausnahmebehandlungsfehler ignoriert

en: ignoring asm-specifier for non-static local variable %q+D
de: asm-Symbol für nicht-statische lokale Variable %q+D wird ignoriert

en: ignoring attributes applied to %qT after definition
de: auf %qT nach einer Definition angewandte Attribute werden ignoriert

en: ignoring attributes applied to class type %qT outside of definition
de: auf Klassentyp %qT angewandte Attribute außerhalb einer Definition werden ignoriert

en: ignoring attributes applied to dependent type %qT without an associated declaration
de: auf abhängigen Typ %qT angewandte Attribute ohne zugehörige Deklaration werden ignoriert

en: ignoring duplicate directory "%s"
de: doppeltes Verzeichnis »%s« wird ignoriert

en: ignoring malformed #pragma longcall
de: Falsch geformtes #pragma longcall wird ignoriert

en: ignoring nonexistent directory "%s"
de: nicht vorhandenes Verzeichnis »%s« wird ignoriert

en: ignoring packed attribute because of unpacked non-POD field %q+#D
de: »gepackt«-Attribut für ungepacktes nicht-POD-Feld %q+#D wird ignoriert

en: ignoring return value of %qD, declared with attribute warn_unused_result
de: Der Rückgabewert von %qD, der mit dem Attribut warn_unused_result deklariert wurde, wird ignoriert

en: ignoring return value of function declared with attribute warn_unused_result
de: Rückgabewert der mit dem Attribut warn_unused_result definierten Funktion wird ignoriert

en: ignoring unknown option %q.*s in %<-fdump-%s%>
de: unbekannte Option %q.*s in %<-fdump-%s%> wird ignoriert

en: illegal aggregate type %qE specified for instance variable %qs
de: unzulässiger Aggregattyp %qE für Instanzvariable %qs angegeben

en: illegal operand detected
de: ungültiger Operand wurde gefunden

en: illegal reference type specified for instance variable %qs
de: unzulässiger Referenztyp für Instanzvariable %qs angegeben

en: implicit conversion from %qT to %qT to match other operand of binary expression
de: implizite Umwandlung von %qT in %qT zur Anpassung an anderen Operanden des Binärausdrucks

en: implicit conversion from %qT to %qT to match other result of conditional
de: implizite Umwandlung von %qT in %qT um an anderes Ergebnis von Bedingung anzupassen

en: implicit conversion from %qT to %qT when passing argument to function
de: implizite Umwandlung von %qT in %qT bei Übergabe von Argument an Funktion

en: implicit declaration of function %qE
de: Implizite Deklaration der Funktion %qE

en: implicit dereference will not access object of type %qT in for increment expression
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in Erhöhungsausdruck zu

en: implicit dereference will not access object of type %qT in left operand of comma operator
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in linkem Operanden des Kommaoperators zu

en: implicit dereference will not access object of type %qT in right operand of comma operator
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in rechtem Operanden des Kommaoperators zu

en: implicit dereference will not access object of type %qT in second operand of conditional expression
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in zweitem Operanden des bedingten Ausdrucks zu

en: implicit dereference will not access object of type %qT in statement
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in Anweisung zu

en: implicit dereference will not access object of type %qT in third operand of conditional expression
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in drittem Operanden des bedingten Ausdrucks zu

en: implicitly popped regs must be grouped at top of stack
de: implizit geholte (»pop«) Register müssen oben auf dem Stack gruppiert werden

en: implied END DO
de: impliziertes END DO

en: impossible constraint in %<asm%>
de: unmögliche Bedingung in »asm«

en: impossible register constraint in %<asm%>
de: unmögliche Registerbedingung in %<asm%>

en: impossible type assertion: type does not implement interface
de: unmögliche Typenbehauptung: Typ implementiert nicht Schnittstelle

en: in %s, at %s:%d
de: in %s, bei %s:%d

en: in C++98 %qD must be initialized by constructor, not by %<{...}%>
de: in C++98 muss %qD mit Konstruktor initialisiert werden, nicht mit %<{...}%>

en: in argument to unary !
de: in Argument für unäres !

en: in basic block %d:
de: im Basis-Block %d:

en: in declaration %q+D
de: in Deklaration %q+D

en: in passing argument %P of %q+D
de: bei Übergabe des Arguments %P von %q+D

en: in statement
de: in Anweisung

en: in template argument for type %qT
de: in Templateargument für Typ %qT

en: in-class initialization of static data member %q#D of non-literal type
de: Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit nicht eingebautem Typ

en: inacessible plugin file %s expanded from short plugin name %s: %m
de: nicht zugreifbare Plugin-Datei %s aus kurzem Plugin-Namen %s erzeugt: %m

en: inappropriate accumulator for %qs
de: unpassender Akkumulator für %qs

en: incoming edge count does not match number of PHI arguments
de: Eingehende Kantenzahl passt nicht zur Anzahl der PHI-Argumente

en: incompatible address space qualifiers %qs and %qs
de: Inkompatible Adressraumkennzeichen %s und %s

en: incompatible implicit declaration of built-in function %qD
de: Unverträgliche implizite Deklaration der eingebauten Funktion %qD

en: incompatible implicit declaration of function %qD
de: Unverträgliche implizite Deklaration der Funktion %qD

en: incompatible type for argument %d of %qE
de: Inkompatibler Typ für Argument %d von %qE

en: incompatible type for map index
de: inkompatible Typen für Abbildungsindex

en: incompatible type for method %s%s%s
de: Inkompatibler Typ für Methode %s%s%s

en: incompatible type for method %s%s%s (%s)
de: Inkompatibler Typ für Methode %s%s%s (%s)

en: incompatible type for receiver
de: inkompatible Typen für Empfänger

en: incompatible types in PHI argument %u
de: inkompatible Typen in PHI-Argument %u

en: incompatible types in assignment of %qT to %qT
de: unverträgliche Typen in Zuweisung von %qT an %qT

en: incompatible types in binary expression
de: inkompatible Typen in binärem Ausdruck

en: incompatible types in send
de: inkompatible Typen in »send«

en: incompatible types when assigning to type %qT from type %qT
de: unverträgliche Typen bei Zuweisung an Typ %qT von Typ %qT

en: incompatible types when initializing type %qT using type %qT
de: inkompatible Typen bei Initialisierung von Typ %qT mit Typ %qT

en: incompatible types when returning type %qT but %qT was expected
de: unverträgliche Typen bei Rückgabe von Typ %qT, aber %qT wurde erwartet

en: incomplete implementation of category %qE
de: unvollständige Implementierung der Kategorie %qE

en: incomplete implementation of class %qE
de: unvollständige Implementierung der Klasse %qE

en: incomplete type %qT does not have member %qD
de: unvollständiger Typ %qT hat kein Element %qD

en: incomplete type %qT not allowed
de: unvollständiger Typ %qT nicht erlaubt

en: incomplete type %qT used in nested name specifier
de: unvollständiger Typ %qT in geschachtelter Namensangabe verwendet

en: inconsistent begin/end types in range-based for: %qT and %qT
de: widersprüchliche Anfang-/Ende-Typen in bereichsbasiertem »for«: %qT und %qT

en: inconsistent deduction for %qT: %qT and then %qT
de: widersprüchliche Herleitung für %qT: %qT und dann %qT

en: inconsistent instance variable specification
de: widersprüchliche Spezifikation von Instanzvariable

en: inconsistent operand constraints in an %<asm%>
de: inkonsistente Operandenbedingungen in einem %<asm%>

en: inconsistent types %qT and %qT deduced for lambda return type
de: widersprüchliche Typen %qT und %qT für Lambda-Rückgabetypen hergeleitet

en: incorrect entry in label_to_block_map
de: falscher Eintrag in label_to_block_map

en: incorrect insn:
de: Falscher Befehl:

en: incorrect setting of landing pad number
de: falsches Setzen von Landefeld-Zahl

en: incorrect sharing of tree nodes
de: falscher gemeinsame Verwendung von Baumknoten

en: increment of constant field %qD
de: Erhöhung des konstanten Feldes %qD

en: increment of enumeration value is invalid in C++
de: Schrittweite von Aufzählungswerten (enum) ist in C++ ungültig

en: increment of function %qD
de: Erhöhung der Funktion %qD

en: increment of member %qD in read-only object
de: Erhöhung des Elements %qD in schreibgeschütztem Objekt

en: increment of pointer to unknown structure
de: Erhöhung eines Zeigers auf unbekannte Struktur

en: increment of read-only location %qE
de: Erhöhung der schreibgeschützten Speicherstelle %qE

en: increment of read-only member %qD
de: Erhöhung des schreibgeschützten Elementes %qD

en: increment of read-only named return value %qD
de: Erhöhung des schreibgeschützten benannten Rückgabewertes %qD

en: increment of read-only parameter %qD
de: Erhöhung des schreibgeschützten Parameters %qD

en: increment of read-only reference %qD
de: Erhöhung der schreibgeschützten Referenz %qD

en: increment of read-only variable %qD
de: Erhöhung der schreibgeschützten Variable %qD

en: index %E denotes an offset greater than size of %qT
de: Index %E markiert einen Offset größer als die Größe von %qT

en: index in dimension %d is out of bounds at %L
de: Index in Dimension %d ist außerhalb der Grenzen bei %L

en: index must be integer
de: Index muss eine Ganzzahl sein

en: index value instead of field name in union initializer
de: Indexwert statt Feldname in Union-Initialisierung

en: index value is out of bound
de: Indexwert ist außerhalb der Grenzen

en: indirect function %q+D cannot be declared weak
de: indirekte Funktion %q+D kann nicht als »schwach« deklariert werden

en: indirect function %q+D cannot be declared weakref
de: indirekte Funktion %q+D kann nicht als »weakref« deklariert werden

en: indirect function call with a yet undetermined callee
de: Indirekter Funktionsaufruf mit noch unbekanntem Aufrufer

en: indirection will not access object of incomplete type %qT in for increment expression
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in Erhöhungsausdruck zu

en: indirection will not access object of incomplete type %qT in left operand of comma operator
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in linkem Operanden des Kommaoperators zu

en: indirection will not access object of incomplete type %qT in right operand of comma operator
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in rechtem Operanden des Kommaoperators zu

en: indirection will not access object of incomplete type %qT in second operand of conditional expression
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in zweitem Operanden des bedingten Ausdrucks zu

en: indirection will not access object of incomplete type %qT in statement
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in Anweisung zu

en: indirection will not access object of incomplete type %qT in third operand of conditional expression
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in drittem Operanden des bedingten Ausdrucks zu

en: indirection will not access object of non-trivially-copyable type %qT in for increment expression
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT in Erhöhungsausdruck zu

en: indirection will not access object of non-trivially-copyable type %qT in left operand of comma operator
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im linken Operanden des Kommaoperators zu

en: indirection will not access object of non-trivially-copyable type %qT in right operand of comma operator
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im rechten Operanden des Kommaoperators zu

en: indirection will not access object of non-trivially-copyable type %qT in second operand of conditional expression
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im zweiten Operanden des bedingten Ausdrucks zu

en: indirection will not access object of non-trivially-copyable type %qT in statement
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT in Anweisung zu

en: indirection will not access object of non-trivially-copyable type %qT in third operand of conditional expression
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im dritten Operanden des bedingten Ausdrucks zu

en: init function found in object %s
de: init-Funktion im Objekt %s gefunden

en: initialization discards %qv qualifier from pointer target type
de: Initialisierung streicht Qualifizierer %qv von Zeiger-Zieltyp

en: initialization from distinct Objective-C type
de: Initialisierung von anderem Objective-C-Typ

en: initialization from incompatible pointer type
de: Initialisierung von inkompatiblem Zeigertyp

en: initialization from pointer to non-enclosed address space
de: Initialisierung von Zeiger auf nicht enthaltenen Adressraum

en: initialization left-hand side might be a candidate for a format attribute
de: Linke-Initialisierung könnte Kandidat für Formatattribut sein

en: initialization makes %q#v qualified function pointer from unqualified
de: Initialisierung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: initialization makes integer from pointer without a cast
de: Initialisierung erzeugt Ganzzahl von Zeiger ohne Typkonvertierung

en: initialization makes pointer from integer without a cast
de: Initialisierung erzeugt Zeiger von Ganzzahl ohne Typkonvertierung

en: initialization of a flexible array member
de: Initialisierung eines flexiblen Feld-Elements

en: initialization of flexible array member in a nested context
de: Initialisierung eines flexiblen Feld-Elements in geschachteltem Kontext

en: initialization of non-const reference type %q#T from rvalue of type %qT
de: Initialisierung eines nicht-konstanten Referenztyps %q#T von R-Wert des Typs %qT

en: initialization of volatile reference type %q#T from rvalue of type %qT
de: Initialisierung des »volatile« Referenztyps %q#T von R-Wert des Typs %qT

en: initializations for multiple members of %qT
de: Initialisierungen für mehrere Elemente von %qT

en: initialized field overwritten
de: initialisiertes Feld überschrieben

en: initialized field with side-effects overwritten
de: initialisiertes Feld mit Seiteneffekten überschrieben

en: initialized variable %q+D is marked dllimport
de: initialisierte Variable %q+D ist als »dllimport« markiert

en: initializer element is not a constant expression
de: Initialisierungselement ist nicht konstant

en: initializer element is not computable at load time
de: Initialisierungs-Element ist zur Lade-Zeit nicht berechenbar

en: initializer element is not constant
de: Initialisierungselement ist nicht konstant

en: initializer ends prematurely
de: Initialisierung endet vorzeitig

en: initializer fails to determine size of %q+D
de: Initialisierung gibt nicht die Größe von %q+D an

en: initializer fails to determine size of %qD
de: Initialisierung gibt nicht die Größe von %qD an

en: initializer for %qT must be brace-enclosed
de: Initialisierung für %qT muss geklammert sein

en: initializer for floating value is not a floating constant
de: Initialisierung für Gleitkommawert ist keine Gleitkommakonstante

en: initializer for integer/fixed-point value is too complicated
de: Initialisierung für Ganzzahl-/Gleitkommazahlwert ist zu kompliziert

en: initializer invalid for static member with constructor
de: Initialisierung ungültig für statisches Element mit Konstruktor

en: initializer provided for function
de: Initialisierung für Funktion bereitgestellt

en: initializer specified for non-virtual method %q+D
de: Initialisierung für nicht-virtuelle Methode %q+D angegeben

en: initializer specified for static member function %qD
de: Initialisierung für statische Element-Funktion %qD angegeben

en: initializer-string for array of chars is too long
de: Initialisierungs-Zeichenkette für char-Feld ist zu lang

en: injected-class-name %qD used as template template argument
de: eingegebener Klassenname %qD als Template-Templateargument verwendet

en: inline clone is needed
de: Inline-Kopie erforderlich

en: inline clone with address taken
de: Inline-Kopie mit Adresse genommen

en: inline code to invalidate instruction cache entries after setting up nested function trampolines
de: Code inline einbetten, um Befehlscache nach dem Aufsetzen verschachtelter Funktionstrampolines zu verwerfen

en: inline declaration of %qD follows declaration with attribute noinline
de: inline-Deklaration von %qD folgt Deklaration mit Attribut noinline

en: inline function %q+D declared as  dllimport: attribute ignored
de: »inline«-Funktion %q+D ist als »dllimport« deklariert: Attribut ignoriert

en: inline function %q+D declared but never defined
de: Inline-Funktion %q+D deklariert, aber nirgendwo definiert

en: inline function %q+D declared weak
de: »inline«-Funktion %q+D als »schwach« deklariert

en: inline function %q+D given attribute noinline
de: inline-Funktion %q+D wurde das Attribut »noinline« gegeben

en: inline function %q+D is declared as dllimport: attribute ignored
de: »inline«-Funktion %q+D ist als »dllimport« deklariert: Attribut ignoriert

en: inline function %q+D used but never defined
de: inline-Funktion %q+D verwendet, aber nirgendwo definiert

en: inline function %qD given attribute noinline
de: inline-Funktion %qD wurde das Attribut »noinline« gegeben

en: inline namespaces only available with -std=c++0x or -std=gnu++0x
de: »inline« Namensräume nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: inlined_to pointer is set but no predecessors found
de: inlined_to-Zeiger gesetzt, aber keine Vorgänger gefunden

en: inlined_to pointer is wrong
de: inlined_to-Zeiger ist falsch

en: inlined_to pointer refers to itself
de: Inlined_to-Zeiger verweist auf sich selbst

en: inlined_to pointer set for noninline callers
de: inlined_to-Zeiger für Nicht-Inline-Aufrufer gesetzt

en: inlining failed in call to %q+F: %s
de: »inline« beim Aufruf von %q+F gescheitert: %s

en: input operand constraint contains %qc
de: Bedingung für Eingabeoperanden enthält %qc

en: insn %d basic block pointer is %d, should be %d
de: Basisblockzeiger des Befehls %d ist %d, sollte %d sein

en: insn %d in footer of bb %d has non-NULL basic block
de: Befehl %d am Ende des Basisblocks %d hat Nicht-NULL als Basisblock

en: insn %d in header of bb %d has non-NULL basic block
de: Befehl %d im Kopf des Basisblockes %d hat Nicht-NULL als Basisblock

en: insn %d inside basic block %d but block_for_insn is %i
de: Befehl %d innerhalb des Basis-Blockes %d, aber block_for_insn ist %i

en: insn %d inside basic block %d but block_for_insn is NULL
de: Befehl %d innerhalb des Basis-Blockes %d, aber block_for_insn ist NULL

en: insn %d is in multiple basic blocks (%d and %d)
de: Befehl %d ist in mehreren Basisblöcken (%d und %d)

en: insn %d outside of basic blocks has non-NULL bb field
de: Befehl %d außerhalb eines Basis-Blockes hat Nicht-NULL als Basisblockfeld

en: insn contains an invalid address !
de: Befehl enthält eine ungültige Adresse!

en: insn does not satisfy its constraints:
de: Befehl erfüllt nicht seine Bedingungen:

en: insn outside basic block
de: Befehl außerhalb eines Basis-Blockes

en: install: %s%s
de: installiere: %s%s

en: instance variable %qE accessed in class method
de: in Klassenmethode wird auf Instanzvariable %qE zugegriffen

en: instance variable %qE is %s; this will be a hard error in the future
de: Instanzvariable %qE ist %s; dies wird zukünftig ein schwerer Fehler sein

en: instance variable %qE is declared %s
de: Instanzvariable %qE ist als »%s« deklariert

en: instance variable %qE is declared private
de: Instanzvariable %qE ist als »private« deklariert

en: instance variable %qs has unknown size
de: Instanzvariable %qs hat unbekannte Größe

en: instance variable %qs is declared private
de: Instanzvariable %qs ist als »private« deklariert

en: instance variable %qs uses flexible array member
de: Instanzvariable %qs verwendet flexibles Feldelement

en: instance variable assignment has been intercepted
de: Zuweisung der Instanzvariable wurde abgefangen

en: instantiation of %q+D as type %qT
de: Instanziierung von %q+D als Typ %qT

en: instruction never executed
de: Anweisung wird niemals ausgeführt

en: instruction scheduling not supported on this target machine
de: Befehlsplanung wird von dieser Zielmaschine nicht unterstützt

en: insufficient arguments to overloaded function %s
de: Zu wenig Argumente für überladene Funktion %s

en: insufficient contextual information to determine type
de: unzureichende Informationen für Typbestimmung aus Kontext

en: int-array initialized from incompatible wide string
de: Ganzzahlfeld mit unverträglicher wide-Zeichenkette initialisiert

en: int-array initialized from non-wide string
de: int-Feld mit Nicht-wide-Zeichenkette initialisiert

en: integer constant is too large for %<unsigned long%> type
de: Ganzzahlkonstante ist zu groß für %<unsigned long%>-Typ

en: integer kind=8 not available for -fdefault-integer-8 option
de: integer kind=8 nicht verfügbar für Option -fdefault-integer-8

en: integer overflow in expression
de: Ganzzahlüberlauf in Ausdruck

en: integral expression %qE is not constant
de: Ganzzahlausdruck %qE ist nicht konstant

en: inter-module optimizations not implemented for C++
de: Optimierungen zwischen Modulen noch nicht implementiert für C++

en: interface %qE does not have valid constant string layout
de: die Schnittstelle %qE hat keine gültige Form einer konstanten Zeichenkette

en: internal and protected visibility attributes not supported in this configuration; ignored
de: interne und geschützte Sichtbarkeitsattribute werden in dieser Konfiguration nicht unterstützt; ignoriert

en: internal compiler error.  Bad address:
de: Interner Compiler-Fehler. Falsche Adresse:

en: internal compiler error.  Incorrect shift:
de: Interner Compiler-Fehler. Falsche Verschiebung:

en: internal compiler error.  Unknown mode:
de: Interner Compiler-Fehler. Unbekannter Modus:

en: internal compiler error:
de: interner Compiler-Fehler:

en: internal consistency failure
de: internes Konsistenzproblem

en: internal error - invalid Utf8 name
de: interner Fehler - ungültiger UTF-8-Name

en: internal error: bad register: %d
de: interner Fehler: falsches Register: %d

en: internal error: builtin function %s had an unexpected return type %s
de: interner Fehler: eingebaute Funktion %s hatte unerwarteten Rückgabetyp %s

en: internal error: builtin function %s had no type
de: interner Fehler: eingebaute Funktion %s hatte keinen Typ

en: internal error: builtin function to %s already processed
de: interner Fehler: Eingebaute Funktion auf %s bereits verarbeitet

en: internal error: cris_side_effect_mode_ok with bad operands
de: interner Fehler: cris_side_effect_mode_ok mit falschen Operanden

en: internal error: sideeffect-insn affecting main effect
de: interner Fehler: Seiteneffekt-Befehl wirkt sich auf Haupteffekt aus

en: internal function
de: interne Funktion

en: internal gcc abort in %s, at %s:%d
de: interner GCC-Abbruch in %s, bei %s:%d

en: internal unit in WRITE
de: interne Einheit in WRITE

en: interrupt Service Routines cannot be coded in Thumb mode
de: Interrupt-Dienst-Routinen können nicht im »Thumb«-Modus codiert werden

en: interrupt function must have no arguments
de: Interruptfunktion darf keine Argumente haben

en: interrupt function must have return type of void
de: Interruptfunktion muss Rückgabetyp »void« haben

en: interrupt handlers cannot be MIPS16 functions
de: Interrupthandler können keine MIPS16-Funktionen sein

en: interrupt_thread is available only on fido
de: interrupt_thread ist nur auf Fido verfügbar

en: intrinsic variable which isn't a procedure
de: innere Variable, die keine Prozedur ist

en: invalid #pragma %s
de: ungültiges #pragma %s

en: invalid %%-code
de: ungültiger %%-Code

en: invalid %%A operand
de: ungültiger %%A-Operand

en: invalid %%B operand
de: ungültiger %%B-Operand

en: invalid %%C value
de: Ungültiger %%C-Wert

en: invalid %%D value
de: ungültiger %%D-Wert

en: invalid %%E value
de: Ungültiger %%E-Wert

en: invalid %%F value
de: ungültiger %%F-Wert

en: invalid %%G mode
de: ungültiger Modus %%G

en: invalid %%G value
de: ungültiger %%G-Wert

en: invalid %%H value
de: Ungültiger %%H-Wert

en: invalid %%J code
de: ungültiger %%J-Code

en: invalid %%J value
de: Ungültiger %%J-Wert

en: invalid %%K value
de: ungültiger %%K-Wert

en: invalid %%L code
de: ungültiger %%L-Code

en: invalid %%L value
de: Ungültiger %%L-Wert

en: invalid %%M value
de: Ungültiger %%M-Wert

en: invalid %%N value
de: Ungültiger %%N-Wert

en: invalid %%O value
de: ungültiger %%O-Wert

en: invalid %%P operand
de: unbekannter Operand für %%P

en: invalid %%P value
de: Ungültiger %%P-Wert

en: invalid %%R value
de: Ungültiger %%R-Wert

en: invalid %%S value
de: ungültiger %%S-Wert

en: invalid %%T value
de: ungültiger %%T-Wert

en: invalid %%U value
de: Ungültiger %%U-Wert

en: invalid %%Y operand
de: ungültiger %%Y-Operand

en: invalid %%c operand
de: ungültiger %%c-Operand

en: invalid %%c value
de: Ungültiger %%c-Wert

en: invalid %%d operand
de: ungültiger %%d-Operand

en: invalid %%d value
de: ungültiger %%d-Wert

en: invalid %%f operand
de: ungültiger %%f-Operand

en: invalid %%f value
de: ungültiger %%f-Wert

en: invalid %%h value
de: Ungültiger %%h-Wert

en: invalid %%j code
de: ungültiger %%j-Code

en: invalid %%j value
de: ungültiger %%j-Wert

en: invalid %%k value
de: ungültiger %%k-Wert

en: invalid %%m value
de: Ungültiger %%m-Wert

en: invalid %%p value
de: unbekannter Wert für %%p

en: invalid %%q value
de: ungültiger %%q-Wert

en: invalid %%r value
de: Ungültiger %%r-Wert

en: invalid %%s operand
de: ungültiger %%s-Operand

en: invalid %%s value
de: Ungültiger %%s-Wert

en: invalid %%t/%%b value
de: ungültiger %%t/%%b-Wert

en: invalid %%u value
de: ungültiger %%u-Wert

en: invalid %%v value
de: ungültiger %%v-Wert

en: invalid %%x value
de: ungültiger %%x-Wert

en: invalid %%xn code
de: Ungültiger %%xn-Code

en: invalid %%y value, try using the 'Z' constraint
de: ungültiger %%y-Wert, bitte »Z«-Bedingung probieren

en: invalid 'asm':
de: ungültiges »asm«:

en: invalid (pointer) operands to plus/minus
de: ungültige (Zeiger-) Operanden für Plus/Minus

en: invalid --param value %qs
de: ungültiger Wert für --param: %qs

en: invalid ABI option: -mabi=%s
de: ungültige ABI-Option -mabi=%s

en: invalid AE type specified (%s)
de: ungültiger AE-Typ angegeben (%s)

en: invalid COND_EXPR in gimple assignment
de: ungültige COND_EXPR in GIMPLE-Zuweisung

en: invalid GIMPLE statement
de: ungültige GIMPLE-Anweisung

en: invalid IACC argument
de: ungültiges IACC-Argument

en: invalid LHS in gimple call
de: ungültige LHS in GIMPLE-Aufruf

en: invalid Objective-C++ selector name
de: Ungültiger Objective-C++-Selektorname

en: invalid PC in line number table
de: ungültiges PC in Zeilennummerntabelle

en: invalid PHI argument
de: ungültiges PHI-Argument

en: invalid PHI result
de: ungültiges PHI-Ergebnis

en: invalid UNSPEC as operand
de: ungültiges UNSPEC als Operand

en: invalid Z register replacement for insn
de: ungültiger Z-Register-Ersatz für Befehl

en: invalid __fp16 format option: -mfp16-format=%s
de: Ungültige Option für __fp16-Format: -mfp16-format=%s

en: invalid abstract return type for function %q+#D
de: ungültiger abstrakter Rückgabetyp für Funktion %q+#D

en: invalid abstract return type for member function %q+#D
de: ungültiger abstrakter Rückgabetyp für Elementfunktion %q+#D

en: invalid abstract type %qT for %qE
de: ungültiger abstrakter Typ %qT für %qE

en: invalid abstract type for %q+D
de: ungültiger abstrakter Typ für %q+D

en: invalid access to non-static data member %qD  of NULL object
de: ungültiger Zugriff auf nicht-statisches Datenelement %qD des NULL-Objektes

en: invalid access to non-static data member %qD of NULL object
de: ungültiger Zugriff auf nicht-statisches Datenelement %qD des NULL-Objektes

en: invalid address
de: ungültige Adresse

en: invalid address for 'O' output modifier
de: ungültige Adresse für Ausgabemodifizierer »O«

en: invalid address for 'R' output modifier
de: ungültige Adresse für Ausgabemodifizierer »R«

en: invalid address for 'S' output modifier
de: ungültige Adresse für Ausgabemodifizierer »S«

en: invalid address operand in MEM_REF
de: ungültiger Adressoperand in MEM_REF

en: invalid address operand in in TARGET_MEM_REF
de: invalid address operand in TARGET_MEM_REF

en: invalid addressing mode
de: ungültiger Adressierungsmodus

en: invalid alignment for %<#pragma align%>, ignoring
de: ungültige Ausrichtung für %<#pragma align%> - ignoriert

en: invalid application of %<__alignof%> to a bit-field
de: ungültige Anwendung von %<__alignof%> auf ein Bitfeld

en: invalid application of %<sizeof%> to a bit-field
de: ungültige Anwendung von %<sizeof%> auf ein Bitfeld

en: invalid application of %<sizeof%> to a function type
de: Ungültige Anwendung von %<sizeof%> auf einen Funktionstypen

en: invalid application of %qs to a member function
de: ungültige Anwendung von %qs auf Elementfunktion

en: invalid application of %qs to a void type
de: Ungültige Anwendung von %qs auf einen void-Typen

en: invalid application of %qs to incomplete type %qT
de: Ungültige Anwendung von %qs auf unvollständigen Typen %qT

en: invalid argument %qs to -fdebug-prefix-map
de: ungültiges Argument %qs für -fdebug-prefix-map

en: invalid argument of %qE attribute
de: ungültiges Argument für Attribut %qE

en: invalid argument of %qs attribute
de: ungültiges Argument für Attribut %qs

en: invalid argument to %<__builtin_frame_address%>
de: Ungültiges Argument für %<__builtin_frame_address%>

en: invalid argument to %<__builtin_return_address%>
de: Ungültiges Argument für %<__builtin_return_address%>

en: invalid argument to built-in function
de: ungültiges Argument für eingebaute Funktion

en: invalid argument to gimple call
de: ungültiges Argument für GIMPLE-Aufruf

en: invalid array assignment
de: Ungültiger Feldzuweisung

en: invalid base-class specification
de: ungültige Spezifizierung der Basisklasse

en: invalid branch to/from an OpenMP structured block
de: ungültiger Zweig zu/von strukturiertem OpenMP-Block

en: invalid cast from type %qT to type %qT
de: ungültige Umwandlung von Typ %qT in Typ %qT

en: invalid cast of an rvalue expression of type %qT to type %qT
de: ungültige Typumwandlung eines R-Wert-Ausdrucks des Typs %qT in Typ %qT

en: invalid cast to function type %qT
de: ungültige Umwandlung in Funktionstyp %qT

en: invalid class name in declaration of %qD
de: ungültiger Klassenname in Deklaration von %qD

en: invalid combination of multiple type-specifiers
de: ungültige Kombination mehrerer Typ-Spezifizierer

en: invalid comparison code in gimple cond
de: ungültiger Vergleichscode in GIMPLE-Bedingung

en: invalid comparison operator for 'E' output modifier
de: ungültiger Vergleichsoperator für Ausgabemodifizierer »E«

en: invalid conditional operand
de: ungültiger bedingter Operand

en: invalid const_cast from type %qT to type %qT
de: ungültiges const_cast von Typ %qT in Typ %qT

en: invalid const_cast of an rvalue of type %qT to type %qT
de: ungültiges const_cast eines R-Wertes des Typs %qT in Typ %qT

en: invalid const_double operand
de: ungültiger const_double-Operand

en: invalid constant - try using an output modifier
de: Ungültige Konstante - anderen Ausgabemodifizierer probieren

en: invalid constant for output modifier '%c'
de: ungültige Konstante für Ausgabemodifizierer »%c«

en: invalid constant in %<#pragma pack%> - ignored
de: ungültige Konstante in %<#pragma pack%> - ignoriert

en: invalid constraints for operand
de: ungültige Bedingungen für Operand

en: invalid constructor; you probably meant %<%T (const %T&)%>
de: ungültiger Konstruktor; wahrscheinlich war %<%T (const %T&)%> gemeint

en: invalid controlling predicate
de: Steuerprädikat ungültig

en: invalid conversion from %<__fpreg%>
de: ungültige Umwandlung von %<__fpreg%>

en: invalid conversion from %qT to %qT
de: ungültige Umwandlung von %qT in %qT

en: invalid conversion in gimple call
de: ungültige Umwandlung in GIMPLE-Aufruf

en: invalid conversion in return statement
de: ungültige Umwandlung in »return«-Anweisung

en: invalid conversion to %<__fpreg%>
de: ungültige Umwandlung in %<__fpreg%>

en: invalid conversion to type %qT from type %qT
de: ungültige Umwandlung in Typ %qT von Typ %qT

en: invalid coprocessor register %qE
de: ungültiges Koprozessor-Register %qE

en: invalid coprocessor register range
de: ungültiger Registerbereich für Koprozessor

en: invalid covariant return type for %q+#D
de: ungültiger kovarianter Rückgabetyp für %q+#D

en: invalid cpu "%s" for %s"%s"%s
de: ungültige CPU »%s« für %s"%s"%s

en: invalid declaration of %<%T::%E%>
de: ungültige Deklaration von  %<%T::%E%>

en: invalid declaration of member template in local class
de: ungültige Deklaration eines Elementtemplates in lokaler Klasse

en: invalid declarator
de: ungültiger Deklarator

en: invalid default argument for a template template parameter
de: ungültiges Standardargument für einen Template-Templateparameter

en: invalid definition of qualified type %qT
de: ungültige Definition des qualifizierten Typen %qT

en: invalid element type for attribute %qs
de: ungültiger Elementtyp für Attribut %qs

en: invalid entry to OpenMP structured block
de: ungültiger Eintritt in strukturierten OpenMP-Block

en: invalid exit from OpenMP structured block
de: ungültiger Ausgang von strukturiertem OpenMP-Block

en: invalid explicit specialization
de: ungültige explizite Spezialisierung

en: invalid expression - try using an output modifier
de: ungültiger Ausdruck - anderen Ausgabemodifizierer probieren

en: invalid expression as operand
de: ungültiger Ausdruck als Operand

en: invalid expression for min lvalue
de: ungültiger Ausdruck für Min-L-Wert

en: invalid expression for output modifier '%c'
de: ungültiger Ausdruck für Ausgabemodifizierer »%c«

en: invalid expression type for %<#pragma omp atomic%>
de: ungültiger Ausdruckstyp für %<#pragma omp atomic%>

en: invalid first operand of MEM_REF
de: ungültiger erster Operand von MEM_REF

en: invalid floating point abi: -mfloat-abi=%s
de: Ungültiges Gleitkomma-ABI: -mfloat-abi=%s

en: invalid floating point emulation option: -mfpe=%s
de: Ungültige Option für Gleitkommaemulation: -mfpe-%s

en: invalid floating point option: -mfpu=%s
de: Ungültige Gleitkommaoption: -mfpu=%s

en: invalid function declaration
de: ungültige Funktionsdeklaration

en: invalid function in call statement
de: ungültige Funktion in Aufrufanweisung

en: invalid function in gimple call
de: ungültige Funktion in GIMPLE-Aufruf

en: invalid in-class initialization of static data member of non-integral type %qT
de: ungültige Initialisierung innerhalb der Klasse des statischen Datenelements vom nicht eingebauten Typen %qT

en: invalid increment expression
de: Erhöhungsausdruck ungültig

en: invalid initial value for member %qE
de: ungültiger Anfangswert für Element %qE

en: invalid initialization of non-const reference of type %qT from an rvalue of type %qT
de: ungültige Initialisierung einer nicht-konstanten Referenz des Typs %qT von R-Wert des Typs %qT

en: invalid initialization of reference of type %qT from expression of type %qT
de: ungültige Initialisierung einer Referenz des Typs %qT von Ausdruck des Typs %qT

en: invalid initializer
de: ungültige Initialisierung

en: invalid initializer for array member %q#D
de: ungültige Initialisierung für Feldelement %q#D

en: invalid initializer for member function %qD
de: ungültige Initialisierung für Elementfunktion %qD

en: invalid insn:
de: Ungültiger Befehl:

en: invalid iterating variable in fast enumeration
de: ungültiges Schleifenvariable in schneller Aufzählung

en: invalid labels in gimple cond
de: Ungültiger Marken in GIMPLE-Bedingung

en: invalid left hand side of assignment
de: ungültige linke Seite einer Zuweisung

en: invalid linkage-specification
de: ungültige Bindungsspezifikation

en: invalid location for %<pragma %s%>, ignored
de: ungültiger Ort für %<pragma %s%>, ignoriert

en: invalid lvalue in asm output %d
de: ungültiger L-Wert in asm-Ausgabe %d

en: invalid mask
de: ungültige Maske

en: invalid member function declaration
de: ungültige Elementfunktionsdeklaration

en: invalid member template declaration %qD
de: ungültige Elementtemplatedeklaration %qD

en: invalid mul type specified (%s) - expected mac, mul or none
de: ungültiger mul-Typ angegeben (%s) - mac, mul oder none erwartet

en: invalid new of function type
de: ungültiges »new« von Funktionstyp

en: invalid non-type template argument
de: ungültiges Templateargument ohne Typ

en: invalid non-vector operands to vector valued plus
de: ungültige Nicht-Vektor-Operanden für vektorwertiges Plus

en: invalid offset operand in MEM_REF
de: ungültiger Offset-Operand in MEM_REF

en: invalid offset operand in TARGET_MEM_REF
de: ungültiger Offset-Operand in TARGET_MEM_REF

en: invalid offset operand of MEM_REF
de: ungültiger Offset-Operand von MEM_REF

en: invalid operand code '%c'
de: ungültiger Operandencode »%c«

en: invalid operand for 'A' modifier
de: ungültiger Operand für Modifizierer »A«

en: invalid operand for 'D' modifier
de: ungültiger Operand für Modifizierer »D«

en: invalid operand for 'H' modifier
de: ungültiger Operand für Modifizierer »H«

en: invalid operand for 'O' modifier
de: ungültiger Operand für Modifizierer »O«

en: invalid operand for 'T' modifier
de: ungültiger Operand für Modifizierer »T«

en: invalid operand for 'b' modifier
de: ungültiger Operand für Modifizierer »b«

en: invalid operand for 'e' modifier
de: ungültiger Operand für Modifizierer »e«

en: invalid operand for 'm' modifier
de: ungültiger Operand für Modifizierer »m«

en: invalid operand for 'o' modifier
de: ungültiger Operand für Modifizierer »o«

en: invalid operand for 'p' modifier
de: ungültiger Operand für Modifizierer »p«

en: invalid operand for 'z' modifier
de: ungültiger Operand für Modifizierer »z«

en: invalid operand for code '%c'
de: ungültiger Operand für Code »%c«

en: invalid operand for code: '%c'
de: ungültiger Operand für Code: »%c«

en: invalid operand for unary %<&%>
de: ungültiger Operand für unäres %<&%>

en: invalid operand in indirect reference
de: ungültiger Operand in indirekter Referenz

en: invalid operand in return statement
de: ungültiger Operand in »return«-Anweisung

en: invalid operand in the instruction
de: ungültiger Operand im Befehl

en: invalid operand in unary expression
de: ungültiger Operand in unärem Ausdruck

en: invalid operand in unary operation
de: ungültiger Operand in unärer Operation

en: invalid operand modifier letter
de: ungültiger Modifizierer-Buchstabe für Operand

en: invalid operand output code
de: Ungültiger Operanden-Ausgabecode

en: invalid operand size for operand code '%c'
de: ungültige Operandengröße für Operandencode »%c«

en: invalid operand to %%H/%%L code
de: Ungültiger Operand für %%H/%%L-Code

en: invalid operand to %%N code
de: ungültiger Operand für Code %%N

en: invalid operand to %%R
de: ungültiger Operand für %%R

en: invalid operand to %%R code
de: Ungültiger Operand für %%R-Code

en: invalid operand to %%S
de: ungültiger Operand für %%S

en: invalid operand to %%T/%%B code
de: ungültiger Operand für Code %%T/%%B

en: invalid operand to %%U code
de: Ungültiger Operand für %%U-Code

en: invalid operand to %%V code
de: Ungültiger Operand für %%V-Code

en: invalid operand to %%p code
de: ungültiger Operand für Code %%p

en: invalid operand to %%s code
de: ungültiger Operand für Code %%s

en: invalid operand to plus/minus, type is a pointer
de: ungültiger Operand für Plus/Minus, Typ ist ein Zeiger

en: invalid operand to pointer plus, first operand is not a pointer
de: ungültiger Operand für Zeiger-Plus, erster Operand ist kein Zeiger

en: invalid operand to pointer plus, second operand is not an integer with type of sizetype
de: ungültiger Operand für Zeiger-Plus, zweiter Operand ist keine Ganzzahl mit Größentyp

en: invalid operand to switch statement
de: ungültiger Operand für switch-Anweisung

en: invalid operand type used with operand code '%c'
de: ungültiger Operandentyp mit Operandencode »%c« verwendet

en: invalid operands in binary operation
de: ungültige Operanden in binärer Operation

en: invalid operands in gimple comparison
de: ungültige Operanden in GIMPLE-Vergleich

en: invalid operands in ternary operation
de: ungültige Operanden in ternärer Operation

en: invalid operands of types %qT and %qT to binary %qO
de: ungültige Operanden der Typen %qT und %qT für binäres %qO

en: invalid operands to array reference
de: ungültige Operanden in Feldreferenz

en: invalid operands to binary %s (have %qT and %qT)
de: Ungültige Operanden für binäres %s (haben %qT und %qT)

en: invalid operation on %<__fpreg%>
de: ungültige Operation auf %<__fpreg%>

en: invalid operator for %<#pragma omp atomic%>
de: ungültiger Operator für %<#pragma omp atomic%>

en: invalid option for -mcmodel: '%s'
de: ungültige Option für -mcmodel: »%s«

en: invalid option for -mfloat-gprs: '%s'
de: ungültige Option für -mfloat-gprs: »%s«

en: invalid parameter %qs
de: ungültiger Parameter %qs

en: invalid parameter combination for AltiVec intrinsic
de: ungültige Parameterkombination für intrinsisches AltiVec

en: invalid parameter type %qT
de: ungültiger Parametertyp %qT

en: invalid pass positioning operation
de: ungültige Durchlaufpositionierungsoperation

en: invalid pointer mode %qs
de: Ungültiger Zeigermodus %qs

en: invalid pointer to bit-field %qD
de: ungültiger Zeiger auf Bitfeld %qD

en: invalid position or size operand to BIT_FIELD_REF
de: ungültiger Positions- oder Größenoperand für BIT_FIELD_REF

en: invalid punctuation %qc in constraint
de: ungültiges Zeichen %qc in Bedingung

en: invalid pure const state for function
de: ungültiger »pure const«-Status für Funktion

en: invalid pure specifier (only %<= 0%> is allowed)
de: ungültige reine Spezifikation (nur %<= 0%> ist erlaubt)

en: invalid qualifiers on non-member function type
de: ungültige Qualifizierer an Nicht-Element-Funktionstyp

en: invalid qualifying scope in pseudo-destructor name
de: ungültiger angegebener Gültigkeitsbereich in Pseudodestruktor-Name

en: invalid receive on send-only channel
de: ungültiges Empfangen auf Nur-Sende-Kanal

en: invalid receiver type %qs
de: ungültiger Empfängertyp %qs

en: invalid redeclaration of %q+D
de: ungültige Redeklaration von %q+D

en: invalid reference for 'J' output modifier
de: ungültige Referenz für Ausgabemodifizierer »J«

en: invalid reference prefix
de: ungültiger Referenzprefix

en: invalid register in the instruction
de: ungültiges Register im Befehl

en: invalid register in the move instruction
de: ungültiges Register in Kopierbefehl

en: invalid register name for %q+D
de: ungültiger Registername für %q+D

en: invalid return type %qT of constexpr function %q+D
de: ungültiger Rückgabetyp %qT der Funktion %q+D als konstantem Ausdruck

en: invalid rhs for gimple memory store
de: ungültige RHS für GIMPLE-Speicherung

en: invalid rotate insn
de: ungültiger Rotierbefehl

en: invalid rtl sharing found in the insn
de: ungültige gemeinsame rtl-Benutzung in Befehl gefunden

en: invalid schedule kind
de: ungültige Ablaufart

en: invalid second argument to %<__builtin_prefetch%>; using zero
de: Ungültiges zweites Argument für %<__builtin_prefetch%>; es wird Null verwendet

en: invalid send on receive-only channel
de: ungültiges »send« auf Nur-Empfangs-Kanal

en: invalid setter, it must have one argument
de: ungültiger Setter, muss ein Argument haben

en: invalid shift operand
de: ungültiger Schiebeoperand

en: invalid static chain in gimple call
de: ungültige statische Kette in GIMPLE-Aufruf

en: invalid static_cast from type %qT to type %qT
de: ungültiges static_cast vom Typ %qT in den Typ %qT

en: invalid storage class for function %qE
de: ungültige Speicherklasse für Funktion %qE

en: invalid target memregs value '%d'
de: ungültiger Wert »%d« für Ziel-Memregs

en: invalid template declaration of %qD
de: ungültige Templatedeklaration von %qD

en: invalid template-id
de: ungültige Template-ID

en: invalid third argument to %<__builtin_prefetch%>; using zero
de: Ungültiges drittes Argument für %<__builtin_prefetch%>; es wird Null verwendet

en: invalid thread pointer option: -mtp=%s
de: Ungültige Threadzeiger-Option: -mtp=%s

en: invalid type %<void%> for new
de: ungültiger Typ %<void%> für %<new%>

en: invalid type %qT as initializer for a vector of type %qT
de: Ungültiger Typ %qT als Initialisierung für einen Vektor des Typs %qT

en: invalid type %qT declared %<friend%>
de: ungültiger Typ %qT als %<friend%> deklariert

en: invalid type argument (have %qT)
de: ungültiger Argumenttyp (haben %qT)

en: invalid type argument of %<->%> (have %qT)
de: ungültiger Argumenttyp in %<->%> (haben %qT)

en: invalid type argument of array indexing (have %qT)
de: ungültiger Argumenttyp des Feldindex (haben %qT)

en: invalid type argument of implicit conversion (have %qT)
de: ungültiger Argumenttyp in impliziter Umwandlung (haben %qT)

en: invalid type argument of unary %<*%> (have %qT)
de: ungültiger Argumenttyp in unärem %<*%> (haben %qT)

en: invalid type for instance variable
de: ungültiger Typ für Instanzvariable

en: invalid type for iteration variable %qE
de: ungültiger Typ für Schleifenvariable %qE

en: invalid type for make function
de: ungültiger Typ für »make«-Funktion

en: invalid type for parameter %d of constexpr function %q+#D
de: ungültiger Typ für Parameter %d der Funktion %q+#D als konstantem Ausdruck

en: invalid type for property
de: ungültiger Typ für Eigenschaft

en: invalid type in declaration
de: ungültiger Typ in Deklaration

en: invalid types %<%T[%T]%> for array subscript
de: ungültige Typen %<%T[%T]%> für Feldindex

en: invalid types in address space conversion
de: ungültige Typen in Adressraumumwandlung

en: invalid types in conversion to floating point
de: ungültige Typen in Umwandlung zu Gleitkomma

en: invalid types in conversion to integer
de: ungültige Typen in Umwandlung in Ganzzahl

en: invalid types in fixed-point conversion
de: ungültige Typen Festkomma-Umwandlung

en: invalid types in nop conversion
de: ungültige Typen in NOP-Umwandlung

en: invalid unsafe.Pointer conversion
de: ungültige »unsafe.Pointer«-Umwandlung

en: invalid use of %%d, %%x, or %%X
de: ungültige Verwendung von %%d, %%x oder %%X

en: invalid use of %<::%>
de: ungültige Verwendung von %<::%>

en: invalid use of %<auto%>
de: ungültige Verwendung von %<auto%>

en: invalid use of %<auto%> in conversion operator
de: ungültige Verwendung von %<auto%> in Umwandlungsoperator

en: invalid use of %<restrict%>
de: Ungültige Verwendung von %<restrict%>

en: invalid use of %<this%> at top level
de: ungültige Verwendung von %<this%> auf höchster Ebene

en: invalid use of %<this%> in non-member function
de: ungültige Verwendung von %<this%> in Nicht-Element-Funktion

en: invalid use of %qD
de: ungültige Verwendung von %qD

en: invalid use of %qD in linkage specification
de: ungültige Verwendung von %qD in Spezifizierung der Bindung

en: invalid use of %qE to form a pointer-to-member-function
de: ungültige Verwendung von %qE um Zeiger auf Elementfunktion zu erzeugen

en: invalid use of %qT
de: ungültige Verwendung von %qT

en: invalid use of '%%%c'
de: ungültige Verwendung von »%%%c«

en: invalid use of ':' modifier
de: ungültige Verwendung des Modifizierers »:«

en: invalid use of Boolean expression as operand to %<operator--%>
de: ungültige Verwendung eines Boole'schen Ausdruck als Operand für %<operator--%>

en: invalid use of a pointer to an incomplete type in pointer arithmetic
de: ungültige Verwendung eines Zeigers auf einen unvollständigen Typen in Zeigerarithmetik

en: invalid use of array indexing on pointer to member
de: ungültige Verwendung von Feldindizierung bei Zeiger auf Element

en: invalid use of array with unspecified bounds
de: falsche Benutzung eines Feldes mit unbekannten Grenzen

en: invalid use of const_cast with type %qT, which is a pointer or reference to a function type
de: ungültige Verwendung von const_cast mit Typ %qT, das ein Zeiger oder Referenz auf Funktionstyp ist

en: invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type
de: ungültige Verwendung von const_cast mit Typ %qT, das weder Zeiger, Referenz, noch vom Typ eines Zeigers auf Datenelement ist

en: invalid use of constructor as a template
de: ungültige Benutzung des Konstruktors als Template

en: invalid use of dependent type %qT
de: ungültige Verwendung des abhängigen Typen %qT

en: invalid use of destructor %qD as a type
de: ungültige Benutzung des Destruktors %qD als Typ

en: invalid use of flexible array member
de: falsche Benutzung eines flexiblen Feldelements

en: invalid use of implicit conversion on pointer to member
de: ungültige Verwendung impliziter Umwandlung bei Zeiger auf Element

en: invalid use of incomplete type %q#T
de: falsche Benutzung des unvollständigen Typs %q#T

en: invalid use of incomplete typedef %qD
de: falsche Benutzung des unvollständigen typedef %qD

en: invalid use of member %q+D in static member function
de: ungültige Verwendung des Elementes %q+D in statischer Elementfunktion

en: invalid use of member (did you forget the %<&%> ?)
de: ungültige Verwendung eines Elements (%<&%> vergessen?)

en: invalid use of non-lvalue array
de: ungültige Verwendung eines Nicht-L-Wert-Feldes

en: invalid use of non-static data member %q+D
de: ungültige Verwendung des nicht-statischen Datenelementes %q+D

en: invalid use of non-static data member %qD
de: ungültige Verwendung des nicht-statischen Datenelementes %qD

en: invalid use of non-static member function
de: falsche Benutzung einer nicht-statischen Elementfunktion

en: invalid use of non-static member function %qD
de: ungültige Verwendung der nicht-statischen Elementfunktion %qD

en: invalid use of nonstatic data member %qE
de: ungültige Benutzung des nicht-statischen Datenelements %qE

en: invalid use of pack expansion expression
de: falsche Benutzung eines Packauflösungs-Ausdruckes

en: invalid use of qualified-name %<%D::%D%>
de: ungültige Verwendung des qualifizierten Namens %<%D::%D%>

en: invalid use of qualified-name %<%T::%D%>
de: ungültige Verwendung des qualifizierten Namens %<%T::%D%>

en: invalid use of qualified-name %<::%D%>
de: ungültige Verwendung des qualifizierten Namens %<::%D%>

en: invalid use of structure with flexible array member
de: ungültige Verwendung einer Struktur mit flexiblem Feldelement

en: invalid use of template template parameter %qT
de: ungültige Verwendung des Parameters %qT für Template-Templateparameter

en: invalid use of template type parameter %qT
de: ungültige Verwendung des Parameters %qT für Templatetyp

en: invalid use of template-id %qD in declaration of primary template
de: ungültige Verwendung der Template-ID %qD in Deklaration des ursprünglichen Templates

en: invalid use of template-name %qE without an argument list
de: ungültige Verwendung des Template-Namens %qE ohne eine Argumentliste

en: invalid use of type
de: ungültige Typ-Verwendung

en: invalid use of type %qT as a default value for a template template-parameter
de: ungültige Verwendung des Typs %qT als Standardwert für einen Template-Templateparameter

en: invalid use of unary %<*%> on pointer to member
de: ungültige Verwendung des unären  %<*%> bei Zeiger auf Element

en: invalid use of undefined type %<%s %E%>
de: falsche Benutzung des undefinierten Typs %<%s %E%>

en: invalid use of void expression
de: falsche Benutzung eines void-Ausdruckes

en: invalid value-initialization of reference type
de: ungültige Wert-Initialisierung von Referenztyp

en: invalid vector permutation constant
de: ungültige Vektorpermutationskonstante

en: invalid vector type for attribute %qE
de: Ungültiger Vektortyp für Attribut %qE

en: invalid vector type for attribute %qs
de: ungültiger Vektortyp für Attribut %qs

en: invalid version number %qs
de: ungültige Versionsnummer %qs

en: invoke[non-static] on static method
de: invoke[non-static] an statischer Methode

en: invokestatic on abstract method
de: invokestatic an abstrakter Methode

en: invokestatic on non static method
de: invokestatic an nichtstatischer Methode

en: ipa reference summary is missing in ltrans unit
de: IPA-Referenzzusammenfassung fehlt in ltrans-Einheit

en: it must be a pointer-to-member of the form %<&X::Y%>
de: es muss ein Zeiger auf ein Element der Form %<&X::Y%> sein

en: it must be the address of a function with external linkage
de: es muss die Adresse einer Funktion mit externer Bindung sein

en: item in READ
de: Element in READ

en: iterating variable in fast enumeration is not an object
de: Zählvariable in schneller Aufzählung ist kein Objekt

en: iteration variable %qD should not be firstprivate
de: Schleifenvariable %qD sollte nicht »firstprivate« sein

en: iteration variable %qD should not be reduction
de: Schleifenvariable %qD sollte nicht Reduktion sein

en: iteration variable %qE should be private
de: Schleifenvariable %qE sollte »private« sein

en: iteration variable %qE should not be firstprivate
de: Schleifenvariable %qE sollte nicht »firstprivate« sein

en: iteration variable %qE should not be reduction
de: Schleifenvariable %qE sollte nicht Reduktion sein

en: iterator variable
de: Iteratorvariable

en: its dest_idx should be %d, not %d
de: sein dest_idx sollte %d sein, nicht %d

en: its scope is only this definition or declaration, which is probably not what you want
de: sein Gültigkeitsbereich umfasst nur diese Definition bzw. Deklaration, was Sie wahrscheinlich nicht wollten

en: ivar %qs used by %<@synthesize%> declaration must be an existing ivar
de: von %<@synthesize%>-Deklaration verwendete ivar %qs muss eine existierende ivar sein

en: iwmmxt abi requires an iwmmxt capable cpu
de: iwmmxt ABI erfordert eine iwmmxt-fähige CPU

en: iwmmxt requires an AAPCS compatible ABI for proper operation
de: iwmmxt erfordert ein AAPCS-komptibles ABI für den richtigen Einsatz

en: jcf-dump: no classes specified
de: jcf-dump: keine Klassen angegeben

en: jump into scope of identifier with variably modified type
de: in Gültigkeitsbereich des Bezeichners mit variabel modifiziertem Typen springen

en: jump into statement expression
de: Sprung in Anweisungs-Ausdruck

en: jump skips variable initialization
de: Sprung lässt Variableninitialisierung aus

en: jump to case label
de: Sprung zur case-Marke

en: jump to label %q+D
de: Sprung zur Marke %q+D

en: jump to label %qD
de: Sprung zur Marke %qD

en: junk at end of #pragma %s
de: Ausschuss am Ende von #pragma %s

en: junk at end of #pragma ADDRESS
de: Ausschuss am Ende von #pragma ADDRESS

en: junk at end of #pragma GCC coprocessor width
de: Ausschuss am Ende von #pragma GCC coprocessor width

en: junk at end of #pragma GCC java_exceptions
de: Ausschuss am Ende von #pragma GCC java_exceptions

en: junk at end of #pragma GCC memregs [0..16]
de: Ausschuss am Ende von #pragma GCC memregs [0..16]

en: junk at end of #pragma ghs endsda
de: Ausschuss am Ende von #pragma ghs endsda

en: junk at end of #pragma ghs endtda
de: Ausschuss am Ende von #pragma ghs endtda

en: junk at end of #pragma ghs endzda
de: Ausschuss am Ende von #pragma ghs endzda

en: junk at end of #pragma ghs interrupt
de: Ausschuss am Ende von #pragma ghs interrupt

en: junk at end of #pragma ghs section
de: Ausschuss am Ende von #pragma ghs section

en: junk at end of #pragma ghs startsda
de: Ausschuss am Ende von #pragma ghs startsda

en: junk at end of #pragma ghs starttda
de: Ausschuss am Ende von #pragma ghs starttda

en: junk at end of #pragma ghs startzda
de: Ausschuss am Ende von #pragma ghs startzda

en: junk at end of #pragma io_volatile
de: Ausschuss am Ende von #pragma io_volatile

en: junk at end of #pragma longcall
de: Ausschuss am Ende von #pragma longcall

en: junk at end of %<#pragma %s%>
de: Ausschuss am Ende von %<#pragma %s%>

en: junk at end of %<#pragma GCC pch_preprocess%>
de: Ausschuss am Ende von %<#pragma GCC pch_preprocess%>

en: junk at end of %<#pragma GCC visibility%>
de: Ausschuss am Ende von %<#pragma GCC visibility%>

en: junk at end of %<#pragma align%>
de: Ausschuss am Ende von %<#pragma align%>

en: junk at end of %<#pragma extern_prefix%>
de: Ausschuss am Ende von %<#pragma extern_prefix%>

en: junk at end of %<#pragma fini%>
de: Ausschuss am Ende von %<#pragma fini%>

en: junk at end of %<#pragma init%>
de: Ausschuss am Ende von %<#pragma init%>

en: junk at end of %<#pragma message%>
de: Ausschuss am Ende von %<#pragma message%>

en: junk at end of %<#pragma pack%>
de: Ausschuss am Ende von %<#pragma pack%>

en: junk at end of %<#pragma pop_options%>
de: Ausschuss am Ende von %<#pragma pop_options%>

en: junk at end of %<#pragma push_options%>
de: Ausschuss am Ende von %<#pragma push_options%>

en: junk at end of %<#pragma redefine_extname%>
de: Ausschuss am Ende von %<#pragma redefine_extname%>

en: junk at end of %<#pragma reset_options%>
de: Ausschuss am Ende von %<#pragma reset_options%>

en: junk at end of %<#pragma weak%>
de: Ausschuss am Ende von %<#pragma weak%>

en: junk at end of '#pragma ms_struct'
de: Ausschuss am Ende von »#pragma ms_struct«

en: junk at end of '#pragma options'
de: Ausschuss am Ende von '#pragma options'

en: junk at end of '#pragma unused'
de: Ausschuss am Ende von '#pragma unused'

en: junk at end of signature string
de: Ausschuss am Ende der Signaturzeichenketten

en: keyword %<export%> not implemented, and will be ignored
de: Schlüsselwort %<export%> nicht implementiert, und wird ignoriert

en: keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)
de: Schlüsselwort %<typename%> in diesem Kontext nicht erlaubt (eine qualifizierte Elementinitialisierung ist implizit ein Typ)

en: keyword %<typename%> not allowed in this context (the base class is implicitly a type)
de: Schlüsselwort %<typename%> nicht erlaubt in diesem Kontext (die Basisklasse ist implizit ein Typ)

en: keyword %<typename%> not allowed outside of templates
de: Schlüsselwort %<typename%> nicht außerhalb von Templates erlaubt

en: label
de: Marke

en: label %q+D declared but not defined
de: Marke %q+D deklariert, aber nicht definiert

en: label %q+D defined but not used
de: Marke %q+D definiert, aber nicht verwendet

en: label %q+D used but not defined
de: Marke %q+D verwendet, aber nicht definiert

en: label %qD defined here
de: Marke %qD hier definiert

en: label %qE referenced outside of any function
de: Marke %qE außerhalb einer Funktion referenziert

en: label at end of compound statement
de: Marke am Ende einer Verbundanweisung

en: label named wchar_t
de: Marke wurde wchar_t genannt

en: lambda expressions only available with -std=c++0x or -std=gnu++0x
de: Lambda-Ausdrücke nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: lambda return type can only be deduced when the return statement is the only statement in the function body
de: Lambda-Rückgabetyp kann nur abgeleitet werden, wenn die Rückgabeanweisung die einzige Anweisung im Funktionskörper ist

en: lambda-expression in unevaluated context
de: Lambda-Ausdruck in ungeprüftem Kontext

en: lang_* check: failed in %s, at %s:%d
de: Überprüfung von lang_*: in %s, bei %s:%d gescheitert

en: language %s not recognized
de: Sprache %s nicht erkannt

en: language string %<"%E"%> not recognized
de: Sprachen-Zeichenkette %<"%E"%> nicht erkannt

en: large fixed-point constant implicitly truncated to fixed-point type
de: große Festkommakonstante implizit auf Festkommatypen abgeschnitten

en: large integer implicitly truncated to unsigned type
de: Große Ganzzahl implizit auf vorzeichenlosen Typen abgeschnitten

en: last argument must be an immediate
de: das letzte Argument muss ein Immediate sein

en: layout of classes derived from empty class %qT may change in a future version of GCC
de: die Anordnung der von der leeren Klasse %qT abgeleiteten Klassen könnte sich in zukünftigen GCC-Versionen ändern

en: ld returned %d exit status
de: ld gab %d als Ende-Status zurück

en: left argument must be a slice
de: linkes Argument muss eine Scheibe sein

en: left operand of comma operator cannot resolve address of overloaded function
de: linker Operand des Komma-Operators kann die Adresse der überladenen Funktion nicht auflösen

en: left operand of comma operator has no effect
de: linker Operand des Komma-Operators hat keinen Effekt

en: left operand of comma operator is a reference, not call, to function %qE
de: linker Operand des Komma-Operators ist eine Referenz, kein Aufruf, zur Funktion %qE

en: left precision
de: linke Präzision

en: left precision in strfmon format
de: linke Präzision im strfmon-Format

en: left rotate count >= width of type
de: linker Rotationszähler >= Breite des Typs

en: left rotate count is negative
de: linker Rotationszähler ist negativ

en: left shift count >= width of type
de: Links-Schiebe-Weite >= Breite des Typs

en: left shift count is negative
de: Links-Schiebe-Weite ist negativ

en: left-hand operand of comma expression has no effect
de: linker Operand des Komma-Ausdrucks hat keinen Effekt

en: left-hand side of assignment might be a candidate for a format attribute
de: linke Seite der Zuweisung könnte ein Kandidat für ein Formatattribut sein

en: length modifier
de: Längenmodifizierer

en: length modifier in printf format
de: Längenmodifizierer im printf-Format

en: length modifier in scanf format
de: Längenmodifizierer im scanf-Format

en: length modifier in strfmon format
de: Längenmodifizierer im strfmon-Format

en: letter %c was found & insn was not CONST_INT
de: Buchstabe %c gefunden und Befehl war nicht CONST_INT

en: libraries: %s
de: Bibliotheken: %s

en: library function %q#D redeclared as non-function %q#D
de: Bibliotheksfunktion %q#D als Nicht-Funktion %q#D redeklariert

en: library lib%s not found
de: Bibliothek lib%s nicht gefunden

en: lo_sum not of register
de: lo_sum nicht von einem Register

en: local class %q#T shall not have static data member %q#D
de: lokale Klasse %q#T sollte nicht statisches Datenelement %q#D haben

en: local declaration of %qE hides instance variable
de: lokale Deklaration von %qE verdeckt Instanzvariable

en: local variable %qD may not appear in this context
de: lokale Variable %qD darf in diesem Kontext nicht auftauchen

en: local variable memory requirements exceed capacity
de: Lokale Variablenspeicheranforderungen überschreiten Kapazität

en: logical %<and%> applied to non-boolean constant
de: logisches %<und%> auf nicht-boolsche Konstante angewendet

en: logical %<and%> of mutually exclusive tests is always false
de: logisches %<und%> sich gegenseitig ausschließender Tests ist immer »falsch«

en: logical %<or%> of collectively exhaustive tests is always true
de: logisches %<oder%> gemeinsam erschöpfender Tests ist immer »wahr«

en: long long constant not a valid immediate operand
de: »long long«-Konstante ist kein gültiger direkter Operand

en: long, short, signed or unsigned used invalidly for %qs
de: long, short, signed oder unsigned ungültig verwendet für %qs

en: lookup of %qT in %qT is ambiguous
de: Nachschlagen von %qT in %qT ist nicht eindeutig

en: loop %d%'s header does not belong directly to it
de: Kopf der Schleife %d gehört nicht direkt zu ihr

en: loop %d%'s header does not have exactly 2 entries
de: Kopf der Schleife %d hat nicht genau 2 Einträge

en: loop %d%'s latch does not belong directly to it
de: Falle der Schleife %d gehört nicht direkt zu ihr

en: loop %d%'s latch does not have exactly 1 successor
de: Falle der Schleife %d hat nicht genau einen Nachfolger

en: loop %d%'s latch does not have header as successor
de: Falle der Schleife %d hat nicht den Kopf als Nachfolger

en: loop %d%'s latch is marked as part of irreducible region
de: Falle der Schleife %d ist als Teil einer irreduziblen Region markiert

en: looser throw specifier for %q+#F
de: lockerer »throw«-Spezifizierer für %q+#F

en: lower value in case label range less than minimum value for type
de: Unterer Wert in case-Marken-Bereich ist kleiner als der Minimalwert des Typs

en: lp_array does not match region_tree
de: lp_array passt nicht zum region_tree

en: lp_array is corrupted for lp %i
de: lp_array ist für lp %i beschädigt

en: lvalue required as decrement operand
de: Als Verringerungsoperand wird L-Wert erfordert

en: lvalue required as increment operand
de: Als Erhöhungsoperand wird L-Wert erfordert

en: lvalue required as left operand of assignment
de: Als linker Operand einer Zuweisung wird L-Wert erfordert

en: lvalue required as unary %<&%> operand
de: Als Operand für unäres %<&%> wird L-Wert erfordert

en: lvalue required in asm statement
de: In asm-Anweisung wird L-Wert erfordert

en: macro name missing after %qs
de: Makroname fehlt hinter %qs

en: making %qD static
de: %qD wird statisch gemacht

en: making multiple clones of %qD
de: mehrfache Kopien von %qD werden erzeugt

en: malformed #pragma ADDRESS variable address
de: Falsch geformtes #pragma ADDRESS <Variable> <Adresse>

en: malformed #pragma GCC coprocessor
de: falsch geformtes #pragma GCC coprocessor

en: malformed #pragma GCC coprocessor subclass
de: Falsch geformtes #pragma GCC coprocessor subclass

en: malformed #pragma GCC visibility push
de: Falsch geformtes #pragma GCC visibility push

en: malformed #pragma builtin
de: Falsch geformtes #pragma builtin

en: malformed #pragma call
de: Falsch geformtes #pragma call

en: malformed #pragma disinterrupt
de: falsch geformtes #pragma disinterrupt

en: malformed #pragma extern_prefix, ignored
de: falsch geformtes #pragma extern_prefix, ignoriert

en: malformed #pragma ghs section
de: falsch geformtes #pragma ghs section

en: malformed #pragma redefine_extname, ignored
de: falsch geformtes #pragma redefine_extname, ignoriert

en: malformed #pragma weak, ignored
de: falsch geformtes #pragma weak, ignoriert

en: malformed %<#pragma %s%>, ignored
de: falsch geformtes %<#pragma %s%>, ignoriert

en: malformed %<#pragma align%>
de: Falsch geformtes %<#pragma align%>

en: malformed %<#pragma align%>, ignoring
de: Falsch geformtes %<#pragma align%> - ignoriert

en: malformed %<#pragma fini%>
de: Falsch geformtes %<#pragma fini%>

en: malformed %<#pragma fini%>, ignoring
de: Falsch geformtes %<#pragma fini%>, ignoriert

en: malformed %<#pragma init%>
de: Falsch geformtes %<#pragma init%>

en: malformed %<#pragma init%>, ignoring
de: Falsch geformtes %<#pragma init%>', ignoriert

en: malformed %<#pragma message%>, ignored
de: falsch geformtes %<#pragma message%>, ignoriert

en: malformed %<#pragma pack%> - ignored
de: falsch geformtes %<#pragma pack%> - ignoriert

en: malformed %<#pragma pack(pop[, id])%> - ignored
de: falsch geformtes %<#pragma pack(pop[, id])%> - ignoriert

en: malformed %<#pragma pack(push[, id][, <n>])%> - ignored
de: falsch geformtes %<#pragma pack(push[, id][, <n>])%> - ignoriert

en: malformed '#pragma ms_struct {on|off|reset}', ignoring
de: Falsch geformtes »#pragma ms_struct {on|off|reset}«, ignoriert

en: malformed '#pragma ms_struct', ignoring
de: Falsch geformtes '#pragma ms_struct', ignoriert

en: malformed '#pragma options align={mac68k|power|reset}', ignoring
de: Falsch geformtes '#pragma options align={mac68k|power|reset}', ignoriert

en: malformed '#pragma options', ignoring
de: Falsch geformtes '#pragma options', ignoriert

en: malformed COLLECT_GCC_OPTIONS
de: ungültige COLLECT_GCC_OPTIONS

en: malformed coprocessor register
de: falsches Koprozessor-Register

en: malformed option -fplugin-arg-%s (missing -<key>[=<value>])
de: falsche Option -fplugin-arg-%s (fehlendes -<Schlüssel>[=<Wert>])

en: malformed option -fplugin-arg-%s (multiple '=' signs)
de: falsche Option -fplugin-arg-%s (mehrere '='-Zeichen)

en: malformed spec function arguments
de: schlechte Argumente für Spezifikationsfunktion

en: malformed spec function name
de: schlechter Name für Spezifikationsfunktion

en: mangling %C
de: %C wird vernichtet

en: mangling new-expression
de: new-Ausdruck wird vernichtet

en: mangling typeof, use decltype instead
de: defektes typeof, stattdessen decltype verwenden

en: mangling unknown fixed point type
de: unbekannter Festkommatyp wird vernichtet

en: mask must be an immediate
de: Maske muss »immediate« sein

en: master region may not be closely nested inside of work-sharing or explicit task region
de: Master-Region darf nicht innerhalb arbeitsteilender oder »explicit task«-Region eng geschachtelt sein

en: matching constraint does not allow a register
de: dazu passende Bedingung erlaubt kein Register

en: matching constraint not valid in output operand
de: dazu passende Bedingung in Ausgabeoperanden ungültig

en: matching constraint references invalid operand number
de: dazu passende Bedingung referenziert ungültige Operandennummer

en: maximum limit of %d namespaces searched for %qE
de: obere Grenze von %d Namensräumen für %qE durchsucht

en: maximum number of basic blocks per function to be analyzed by Graphite
de: Höchstzahl der Basis-Blöcke pro Funktion, die von Graphite analysiert werden

en: maximum number of parameters in a SCoP
de: Höchstzahl der Parameter in einem SCoP

en: maximum value of parameter %qs is %u
de: maximaler Wert des Parameters %qs ist %u

en: may not use both -EB and -EL
de: -EB und -EL können nicht gleichzeitig verwendet werden

en: may not use both -m32 and -m64
de: -m32 und -m64 können nicht zusammen angegeben werden

en: media functions are not available unless -mmedia is used
de: Medienfunktionen sind ohne -mmedia nicht verfügbar

en: member %q+#D with constructor not allowed in anonymous aggregate
de: Element %q+#D mit Konstruktor in anonymem Aggregat nicht erlaubt

en: member %q+#D with constructor not allowed in union
de: Element %q+#D mit Konstruktor nicht erlaubt in Union

en: member %q+#D with copy assignment operator not allowed in anonymous aggregate
de: Element %q+#D mit Zuweisungsoperator ist in anonymem Aggregt nicht erlaubt

en: member %q+#D with copy assignment operator not allowed in union
de: Element %q+#D mit Copy-Zuweisungsoperator ist nicht erlaubt in Union

en: member %q+#D with destructor not allowed in anonymous aggregate
de: Element %q+#D mit Destruktor in anonymem Aggregat nicht erlaubt

en: member %q+#D with destructor not allowed in union
de: Element %q+#D mit Destruktor nicht erlaubt in Union

en: member %qD cannot be declared both virtual and static
de: Element %qD kann nicht gleichzeitig virtuell und statisch deklariert werden

en: member %qD conflicts with virtual function table field name
de: Element %qD steht in Konflikt mit Feldname in virtueller Funktionstabelle

en: member %qD declared as friend before type %qT defined
de: Element %qD als »friend« deklariert, bevor Typ %qT definiert wurde

en: member %qD in read-only object used as %<asm%> output
de: Element %qD in schreibgeschütztem Objekt als %<asm%>-Ausgabe verwendet

en: member %qD is uninitialized reference
de: Element %qD ist nicht initialisierte Referenz

en: member %qD with uninitialized const fields
de: Element %qD mit nicht initialisierten konstanten Feldern

en: member functions are implicitly friends of their class
de: Elementfunktionen sind implizite »friends« ihrer Klasse

en: memory input %d is not directly addressable
de: Speichereingabe %d ist nicht direkt adressierbar

en: memory reference expected for 'O' output modifier
de: Speicherreferenz für Ausgabemodifizierer »O« erwartet

en: memory reference expected for 'R' output modifier
de: Speicherreferenz für Ausgabemodifizierer »R« erwartet

en: memory reference expected for 'S' output modifier
de: Speicherreferenz für Ausgabemodifizierer »S« erwartet

en: method %<%c%E%> declared %<@optional%> and %<@required%> at the same time
de: Methode %<%c%E%> gleichzeitig als %<@optional%> und %<@required%> deklariert

en: method %s%s%s requires a pointer
de: Methode %s%s%s erfordert einen Zeiger

en: method '%s' not found in class
de: Methode »%s« nicht gefunden in Klasse

en: method argument attributes are not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine Attribute für Methodenargumente

en: method attributes are not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine Methodenattribute

en: method attributes can not be specified in @implementation context
de: Methodenattribute können nicht im @implementation-Kontext angegeben werden

en: method attributes must be specified at the end
de: Methodenattribute müssen am Ende angegeben werden

en: method attributes must be specified at the end only
de: Methodenattribute dürfen nur am Ende angegeben werden

en: method call without object
de: Methodenaufruf ohne Objekt

en: method declaration not in @interface context
de: Methodendeklaration nicht im @interface-Kontext

en: method definition for %<%c%E%> not found
de: Methodendefinition für %<%c%E%> nicht gefunden

en: method definition not in @implementation context
de: Methodendefinition nicht im @implementation-Kontext

en: method possibly missing a [super dealloc] call
de: In Methode fehlt möglicherweise ein [super dealloc]-Aufruf

en: method type does not match object type
de: Methodentyp passt nicht zum Objekttyp

en: minimum value of parameter %qs is %u
de: minimaler Wert des Parameters %qs ist %u

en: mips16 function profiling
de: Profiling für mips16-Funktionen

en: mips_debugger_offset called with non stack/frame/arg pointer
de: mips_debugger_offset mit nicht-Stapel/Rahmen/Argument-Zeiger aufgerufen

en: mis-aligned access used for structure bitfield
de: falsch ausgerichteter Zugriff für Strukturbitfeld verwendet

en: mis-aligned access used for structure member
de: falsch ausgerichteter Zugriff für Strukturelement verwendet

en: mismatched argument pack lengths while expanding %<%E%>
de: Argumentpacklängen passen nicht bei Auflösung von %<%E%>

en: mismatched argument pack lengths while expanding %<%T%>
de: Argumentpacklängen passen nicht bei Auflösung von %<%T%>

en: mismatched arguments
de: unpassende Argumente

en: mismatching signature for field '%s' in '%s'
de: unpassende Signatur für Feld »%s« in »%s«

en: misplaced %<@%D%> Objective-C++ construct
de: unpassendes Objective-C++-Konstrukt %<@%D%>

en: misplaced ConstantValue attribute (not in any field)
de: schlecht platziertes ConstantValue-Attribut (in keinem Feld)

en: missing $ operand number in format
de: fehlende $-Operandennummer im Format

en: missing %<(%> after %<#pragma GCC visibility push%> - ignored
de: %<(%> hinter %<#pragma GCC visibility push%> fehlt - ignoriert

en: missing %<(%> after %<#pragma pack%> - ignored
de: fehlendes %<(%> hinter %<#pragma pack%> - ignoriert

en: missing %<=%> (after %<getter%> attribute)
de: fehlendes %<=%> (hinter Attribut %<getter%>)

en: missing %<=%> (after %<setter%> attribute)
de: fehlendes %<=%> (hinter Attribut %<setter%>)

en: missing '(' after '#pragma unused', ignoring
de: Fehlendes '(' hinter '#pragma unused', ignoriert

en: missing ')' after '#pragma unused', ignoring
de: Fehlendes ')' hinter '#pragma unused', ignoriert

en: missing Code attribute
de: fehlendes Code-Attribut

en: missing PHI def
de: Fehlende PHI-Definition

en: missing REG_EH_REGION note in the end of bb %i
de: fehlender Vermerk von REG_EH_REGION am Ende vom bb %i

en: missing [error|warning|ignored] after %<#pragma GCC diagnostic%>
de: [error|warning|ignored] nach %<#pragma GCC diagnostic%> fehlt

en: missing argument to %qs
de: fehlendes Argument für %qs

en: missing barrier after block %i
de: fehlende Sperre nach Block %i

en: missing braces around initializer
de: geschweifte Klammern fehlen um Initialisierung

en: missing braces around initializer for %qT
de: geschweifte Klammern fehlen um Initialisierung für %qT

en: missing callgraph edge for call stmt:
de: Fehlende Aufrufgraph-Kante für call stmt:

en: missing close brace for named operand
de: schließende geschweifte Klammer für benannten Operanden fehlt

en: missing close paren
de: Fehlende schließende Klammer

en: missing collection in fast enumeration
de: die Sammlung in schneller Aufzählung fehlt

en: missing controlling predicate
de: Steuerprädikat fehlt

en: missing definition
de: Fehlende Definition

en: missing edge %i->%i
de: Fehlende Kante %i->%i

en: missing field '%s' in '%s'
de: Feld »%s« fehlt in »%s«

en: missing filename after %qs
de: fehlender Dateiname hinter %qs

en: missing fill character at end of strfmon format
de: fehlendes Füllzeichen am Ende des strfmon-Formates

en: missing increment expression
de: Erhöhungsausdruck fehlt

en: missing initializer
de: fehlende Initialisierung

en: missing initializer for member %qD
de: Initialisierung für Element %qD fehlt

en: missing makefile target after %qs
de: fehlendes Makefile-Ziel hinter %qs

en: missing method %s%s%s
de: fehlende Methode %s%s%s

en: missing number
de: Fehlende Zahl

en: missing open paren
de: öffnende Klammer fehlt

en: missing operand
de: fehlender Operand

en: missing option after %<#pragma GCC diagnostic%> kind
de: Option hinter %<#pragma GCC diagnostic%>-Variante fehlt

en: missing path after %qs
de: fehlender Pfad hinter %qs

en: missing sentinel in function call
de: Wächter in Funktionsaufruf fehlt

en: missing terminating %c character
de: fehlendes abschließendes Zeichen %c

en: missing type-name in typedef-declaration
de: fehlender Typname in typedef-Deklaration

en: mixing C++ and Java catches in a single translation unit
de: Mischen von »catch« in C++ und Java in einzelner Übersetzungseinheit

en: mixing declarations and function-definitions is forbidden
de: Vermischung von Deklarationen und Funktionsdefinitionen ist verboten

en: mode %qs applied to inappropriate type
de: Modus %qs auf unpassenden Typen angewendet

en: module procedure
de: Modulprozedur

en: more than %d operands in %<asm%>
de: mehr als %d Operanden in %<asm%>

en: more than one access specifier in base-specified
de: mehr als ein Zugriff in Basisspezifikation angegeben

en: move insn not handled
de: Kopierbefehl nicht behandelt

en: ms-bitfields not supported for objc
de: MS-Bitfelder nicht unterstützt für objc

en: ms_abi and sysv_abi attributes are not compatible
de: Attribute ms_abi und sysv_abi sind nicht verträglich

en: ms_abi attribute requires -maccumulate-outgoing-args or subtarget optimization implying it
de: Attribut ms_abi erfordert -maccumulate-outgoing-args oder darauf hinauslaufende Unter-Ziel-Optimierung

en: ms_hook_prologue attribute isn%'t compatible with -mfentry for 32-bit
de: Attribut ms_hook_prologue ist mit -mfentry für 32 Bit nicht verträglich

en: ms_hook_prologue is not compatible with nested function
de: ms_hook_prologue ist mit geschachtelter Funktion nicht verträglich

en: mudflap cannot track %qE in stub function
de: Schmutzfänger kann nicht %qE in Stub-Funktion verfolgen

en: mudflap cannot track unknown size extern %qE
de: Schmutzfänger kann nicht externes %qE unbekannter Größe verfolgen

en: mudflap checking not yet implemented for ARRAY_RANGE_REF
de: Schmutzfängerprüfung noch nicht für ARRAY_RANGE_REF implementiert

en: mudflap: this language is not supported
de: Schmutzfänger: diese Sprache wird nicht unterstützt

en: multidimensional array must have bounds for all dimensions except the first
de: multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben

en: multilib exclusion %qs is invalid
de: Multilib-Ausschluss %qs ist ungültig

en: multilib exclusions %qs is invalid
de: Multilib-Ausschlüsse %qs sind ungültig

en: multilib select %qs is invalid
de: Multilib-select %qs ist ungültig

en: multilib spec %qs is invalid
de: Multilib-Spezifikation %qs ist ungültig

en: multiple accesses to volatile structure bitfield because of packed attribute
de: mehrfacher Zugriff auf »volatile« Strukturbitfelder wegen gepackter Attribute

en: multiple accesses to volatile structure member because of packed attribute
de: mehrfacher Zugriff auf »volatile« Strukturelement wegen gepackter Attribute

en: multiple default labels in one switch
de: Mehrere Standardmarken in einem »switch«

en: multiple definition of %q#T
de: mehrfache Definition von %q#T

en: multiple fields in union %qT initialized
de: in Union %qT werden mehrere Felder initialisiert

en: multiple function type attributes specified
de: mehrere Funktionstypattribute angegeben

en: multiple hot/cold transitions found (bb %i)
de: Mehrere heiße/kalte Übergänge gefunden (bb %i)

en: multiple initializations given for %qD
de: mehrere Initialisierungen für %qD angegeben

en: multiple initializations given for base %qT
de: mehrere Initialisierungen für Basis %qT angegeben

en: multiple inline callers
de: mehrere Inline-Aufrufer

en: multiple interrupt attributes not allowed
de: mehrere Interruptattribute sind nicht erlaubt

en: multiple iterating variables in fast enumeration
de: mehrere Schleifenvariablen in schneller Aufzählung

en: multiple methods named %<%c%E%> found
de: mehrere Methoden namens %<%c%E%> gefunden

en: multiple parameters named %qD
de: mehrere Parameter wurden %qD genannt

en: multiple prevailing defs for %qE
de: mehrere vorherrschende Definitionen für %qE

en: multiple selectors named %<%c%E%> found
de: mehrere Selektoren namens %<%c%E%> gefunden

en: multiple storage classes in declaration of %qs
de: mehrere Speicherklassen in Deklaration von %qs

en: multiple storage classes in declaration specifiers
de: mehrere Speicherklassen in Deklaration

en: multiple types in one declaration
de: mehrere Typen in einer Deklaration

en: multiple value function call in single value context
de: Funktionsaufruf mit mehreren Werten in Kontext mit einem Wert

en: must #include <typeinfo> before using typeid
de: vor Verwendung von typeid muss #include <typeinfo> angegeben werden

en: must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>
de: %<.*%> oder %<->*%> muss verwendet werden, um Zeiger auf Element als Funktion in %<%E (...)%> aufzurufen, z.B. %<(... ->* %E) (...)%>

en: mvcle use
de: mvcle-Verwendung

en: mysterious repository information in %s
de: rätselhafte Repository-Information in %s

en: name %qD used in a GNU-style designated initializer for an array
de: Name %qD in benannter Initialisierung im GNU-Stil für ein Feld verwendet

en: name %qT has incomplete type
de: Name %qT hat unvollständigen Typen

en: name lookup of %qD changed
de: Suche nach %qD hat sich geändert

en: name lookup of %qD changed for ISO %<for%> scoping
de: Namenssuche von %qD hat sich für ISO-Regeln zum »for«-Gültigkeitsbereich geändert

en: name missing for member function
de: Name der Elementfunktion fehlt

en: name of class shadows template template parameter %qD
de: Name der Klasse verdeckt Template-Templateparameter %qD

en: name used in a GNU-style designated initializer for an array
de: Name in benannter Initialisierung im GNU-Stil für ein Feld verwendet

en: named return values are no longer supported
de: benannte Rückgabewerte werden nicht mehr unterstützt

en: namespace %qD not allowed in using-declaration
de: namespace %qD in %<using%>-Deklaration nicht erlaubt

en: namespace alias %qD not allowed here, assuming %qD
de: Namensbereich-Alias %qD ist hier nicht erlaubt, %qD angenommen

en: namespace-scope anonymous aggregates must be static
de: anonymes Aggregat im Gültigkeitsbereich eines Namespace muss statisch sein

en: narrowing conversion of %qE from %qT to %qT inside { }
de: verengende Umwandlung von %qE von %qT nach %qT in { }

en: need %<typename%> before %<%T::%E%> because %qT is a dependent scope
de: vor %<%T::%E%> ist %<typename%> erforderlich, da %qT ein abhängiger Gültigkeitsbereich ist

en: need %<typename%> before %qE because %qT is a dependent scope
de: %<typename%> vor %qE erforderlich, da %qT ein abhängiger Gültigkeitsbereich ist

en: need a call-clobbered target register
de: aufrufzerstörtes Zielregister erforderlich

en: need a second call-clobbered general purpose register
de: ein zweites aufrufzerstörtes Mehrzweckregister wird benötigt

en: need explicit conversion
de: ausdrückliche Umwandlungen erforderlich

en: need to insert runtime check for %s
de: Laufzeitprüfung für %s muss eingefügt werden

en: negative insn length
de: negative Befehlslänge

en: negative integer implicitly converted to unsigned type
de: Negative Ganzzahl implizit in vorzeichenlosen Typen konvertiert

en: negative nesting depth of region %i
de: negative Verschachtelungstiefe der Region %i

en: negative shift count
de: negative Schiebeweite

en: negative width in bit-field %q+D
de: negative Breite in Bitfeld %q+D

en: negative width in bit-field %qs
de: Negative Breite in Bitfeld %qs

en: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined
de: weder der Destruktor noch der klassenspezifische Operator »delete« wird aufgerufen, auch wenn sie bei der Klassendefinition deklariert werden

en: nested assembly dialect alternatives
de: geschachtelte Assemblerdialekt-Alternativen

en: nested extern declaration of %qD
de: Geschachtelte extern-Deklaration von %qD

en: nested function %q+D declared but never defined
de: Geschachtelte Funktion %q+D deklariert, aber nirgendwo definiert

en: nested function %qE declared %<extern%>
de: geschachtelte Funktion %qE als %<extern%> deklariert

en: nested function %qs declared %<extern%>
de: geschachtelte Funktion %qs als %<extern%> deklariert

en: nested function trampolines not supported on this target
de: -ffunction-sections wird für dieses Ziel nicht unterstützt

en: nested functions not supported on this target
de: geschachtelte Funktionen werden auf diesem Ziel nicht unterstützt

en: nested redefinition of %<enum %E%>
de: Verschachtelte Redefinition von %<enum %E%>

en: nested redefinition of %<struct %E%>
de: Verschachtelte Redefinition von %<struct %E%>

en: nested redefinition of %<union %E%>
de: Verschachtelte Redefinition von %<union %E%>

en: new cannot be applied to a function type
de: »new« kann nicht auf Funktionstyp angewendet werden

en: new cannot be applied to a reference type
de: »new« kann nicht auf Referenztyp angewendet werden

en: new declaration %q#D
de: neue Deklaration %q#D

en: new types may not be defined in a return type
de: neue Typen dürfen nicht in einem Rückgabetyp definiert werden

en: no %<%D(int)%> declared for postfix %qs
de: kein %<%D(int)%> für Suffix %qs deklariert

en: no %<%D(int)%> declared for postfix %qs, trying prefix operator instead
de: kein %<%D(int)%> für Suffix %qs deklariert, stattdessen wird Präfixoperator versucht

en: no %<%c%E%> method found
de: keine Methode %<%c%E%> gefunden

en: no %q#D member function declared in class %qT
de: keine Elementfunktion %q#D in Klasse %qT deklariert

en: no %qs getter found
de: kein %qs-Getter gefunden

en: no FUNCTION_PROFILER for CRIS
de: kein FUNCTION_PROFILER for CRIS

en: no arguments
de: Keine Argumente

en: no arguments for spec function
de: keine Argumente für Spezifikationsfunktion

en: no class name specified with %qs
de: kein Klassenname mit %qs angegeben

en: no class template named %q#T in %q#T
de: kein Klassentemplate namens %q#T in %q#T

en: no closing %<]%> for %<%%[%> format
de: kein schließendes %<]%> für %<%%[%>-Format

en: no context to resolve type of %qE
de: kein Kontext, um Typ von %qE aufzulösen

en: no corresponding deallocation function for %qD
de: keine passende Freigabefunktion für %qD

en: no coverage for function %qE found
de: keine Überdeckung für Funktion %qE gefunden

en: no data type for mode %qs
de: Kein Datentyp für Zustand %qs

en: no declaration of property %qs found in the interface
de: keine Deklaration der in der Schnittstelle gefundenen Eigenschaft %qs

en: no default argument for %qD
de: kein Standard-Argument für %qD

en: no description yet
de: noch keine Beschreibung

en: no field %qD found in union being initialized
de: kein Feld %qD in initialisierter Union gefunden

en: no immediate_use list
de: Keine Liste zur sofortigen Verwendung

en: no input file specified
de: keine Eingabedatei angegeben

en: no input files
de: keine Eingabedateien

en: no input files; unwilling to write output files
de: keine Eingabedateien; es werden keine Ausgabedateien geschrieben

en: no integral type can represent all of the enumerator values for %qT
de: kein Ganzzahltyp kann alle Aufzählungswerte für %qT darstellen

en: no low registers available for popping high registers
de: keine unteren Register für das Hervorholen der hohen Register verfügbar

en: no match for %<operator%s%> in %<%E %s %E%>
de: keine Übereinstimmung für %<operator%s%> in %<%E %s %E%>

en: no match for %<operator%s%> in %<%E%s%>
de: keine Übereinstimmung für %<operator%s%> in %<%E%s%>

en: no match for %<operator%s%> in %<%s%E%>
de: keine Übereinstimmung für %<operator%s%> in %<%s%E%>

en: no match for %<operator[]%> in %<%E[%E]%>
de: keine Übereinstimmung für %<operator[]%> in %<%E[%E]%>

en: no match for %qs in %<%s %E%>
de: keine Übereinstimmung für %qs in %<%s %E%>

en: no match for call to %<(%T) (%A)%>
de: keine Übereinstimmung für Aufruf von %<(%T) (%A)%>

en: no match for ternary %<operator?:%> in %<%E ? %E : %E%>
de: keine Übereinstimmung für ternären %<operator?:%> in %<%E ? %E : %E%>

en: no matches converting function %qD to type %q#T
de: bei der Umwandlung der Funktion %qD in den Typ %q#T gab es keine Übereinstimmungen

en: no matching function for call to %<%D(%A)%>
de: keine passende Funktion für Aufruf von %<%D(%A)%>

en: no matching function for call to %<%T::%s(%A)%#V%>
de: keine passende Funktion für Aufruf von %<%T::%s(%A)%#V%>

en: no matching function for call to %<%T::operator %T(%A)%#V%>
de: keine passende Funktion für Aufruf von %<%T::operator %T(%A)%#V%>

en: no matching push for %<#pragma GCC visibility pop%>
de: kein passendes push für %<#pragma GCC visibility pop%>

en: no matching template for %qD found
de: kein passendes Template für %qD gefunden

en: no member function %qD declared in %qT
de: keine Elementfunktion %qD in %qT deklariert

en: no members matching %<%T::%D%> in %q#T
de: kein Element passt zu %<%T::%D%> in %q#T

en: no object for method call
de: kein Objekt für Methodenaufruf

en: no post-decrement operator for type
de: kein Postdekrementoperator für Typ

en: no post-increment operator for type
de: kein Postinkrementoperator für Typ

en: no pre-decrement operator for type
de: kein Prädekrementoperator für Typ

en: no pre-increment operator for type
de: kein Präinkrementoperator für Typ

en: no previous declaration for %q+D
de: keine vorherige Deklaration für %q+D

en: no previous declaration for %qD
de: keine vorherige Deklaration für %qD

en: no previous prototype for %qD
de: kein vorheriger Prototyp für %qD

en: no processor type specified for linking
de: kein Prozessortyp zum Binden angegeben

en: no profiling of 64-bit code for this ABI
de: kein Profiling von 64-bit-Code für dieses ABI

en: no register in address
de: Kein Register in Adresse

en: no return statement in function returning non-void
de: keine return-Anweisung in nicht void zurückgebender Funktion

en: no sclass for %s stab (0x%x)
de: kein »sclass« für %s Stab (0x%x)

en: no semicolon at end of struct or union
de: kein Semikolon am Ende von »struct« oder »union«

en: no suitable %<operator %s%> for %qT
de: kein geeignetes %<operator %s%> für %qT

en: no suitable %qD found in class %qT
de: Kein passendes %qD in Klasse %qT gefunden

en: no super class declared in @interface for %qE
de: keine Basisklasse im @interface für %qE deklariert

en: no super class declared in interface for %qE
de: keine Basisklasse in Schnittstelle für %qE deklariert

en: no type or storage class may be specified here,
de: hier darf kein Typ oder Speicherklasse angegeben werden,

en: no unique final overrider for %qD in %qT
de: %qD wurde nicht eindeutig und endgültig in %qT überschrieben

en: node has wrong clone list
de: Knoten hat falsche Clone-Liste

en: node has wrong clone_of
de: Knoten hat falsches clone_of

en: node has wrong prev_clone pointer
de: Knoten hat falschen Zeiger prev_clone

en: node is alone in a comdat group
de: Knoten ist allein in einer Comdat-Gruppe

en: node is in clone list but it is not clone
de: Knoten ist in Clone-Liste, aber es ist kein Clone

en: node not found in cgraph_hash
de: Knoten in cgraph_hash nicht gefunden

en: nodes with unreleased memory found
de: Knoten mit nicht freigegebenem Speicher gefunden

en: noexcept-expression evaluates to %<false%> because of a call to %qD
de: noexcept-Ausdruck wird wegen Aufruf von %qD zu %<false%> ausgewertet

en: non-AAPCS derived PCS variant
de: von nicht-AAPCS abgeleitete PCS-Variante

en: non-DECL_ONE_ONLY node in a same_comdat_group list
de: Nicht-DECL_ONE_ONLY-Knoten in einer same_comdat_group-Liste

en: non-const integer argument %u in call to function %qE
de: Nicht-konstantes Ganzzahl-Argument %u in Aufruf von Funktion %qE

en: non-constant array in DATA statement %L
de: nichtkonstantes Feld in DATA-Anweisung %L

en: non-constant array initialization
de: nicht konstante Feldinitialisierung

en: non-constant array size in new, unable to verify length of initializer-list
de: Größe eines nicht konstanten Feldes in new, Länge der Initialisierungsliste kann nicht geprüft werden

en: non-constant compound literals cannot appear in a constant-expression
de: nicht-konstantes zusammengesetztes Literal kann nicht in einem Konstanten-Ausdruck auftreten

en: non-constant condition for static assertion
de: Nicht-konstante Bedingung für statische Behauptung

en: non-constant in-class initialization invalid for static member %qD
de: Initialisierung des nicht konstanten statischen Elements %qD in der Klasse ist ungültig

en: non-deleted function %q+D
de: nicht gelöschte Funktion %q+D

en: non-element sized vector shift of floating point vector
de: Vektorschieben um Nicht-Elementgröße eines Gleitkommavektors

en: non-floating-point argument in call to function %qE
de: Nicht-Gleitkomma-Argument in Aufruf von Funktion %qE

en: non-floating-point arguments in call to function %qE
de: Nicht-Gleitkomma-Argumente in Aufruf von Funktion %qE

en: non-function in gimple call
de: Nicht-Funktion in GIMPLE-Aufruf

en: non-integer operand used with operand code '%c'
de: Nicht-Ganzzahl-Operand mit Operandencode »%c« verwendet

en: non-integral used in condition
de: Nicht-Ganzzahltyp in Bedingung verwendet

en: non-lvalue array in conditional expression
de: Nicht-L-Wert-Feld in bedingtem Ausdruck

en: non-member %qs cannot be declared %<mutable%>
de: Nicht-Element %qs kann nicht als %<mutable%> deklariert sein

en: non-member function %qD cannot have cv-qualifier
de: Nicht-Elementfunktion %qD kann nicht CV-Qualifizierer haben

en: non-memory input %d must stay in memory
de: Eingabe von Nicht-Speicher %d muss im Speicher bleiben

en: non-nested function with variably modified type
de: nicht geschachtelte Funktion mit variabel modifiziertem Typen

en: non-object member %qs cannot be declared %<mutable%>
de: Nicht-Objekt-Element %qs kann nicht als %<mutable%> deklariert sein

en: non-objective-c type '%T' cannot be caught
de: Nicht-Objective-C-Typ »%T« kann nicht aufgefangen werden

en: non-parameter %qs cannot be a parameter pack
de: Nicht-Parameter %qs kann kein Parameterpack sein

en: non-placement deallocation function %q+D
de: nicht-platzierende Freigabefunktion %q+D

en: non-register as LHS of binary operation
de: Nicht-Register als LHS von binärer Operation

en: non-register as LHS of ternary operation
de: Nicht-Register als LHS von ternärer Operation

en: non-register as LHS of unary operation
de: Nicht-Register als LHS von unärer Operation

en: non-scalar type
de: nicht-skalarer Typ

en: non-standard suffix on floating constant
de: Nicht-Standard-Suffix an Gleitkommakonstante

en: non-static const member %q#D, can%'t use default assignment operator
de: nicht-statisches konstantes Element %q#D, Standard-Zuweisungsoperator kann nicht verwendet werden

en: non-static const member %q+#D in class without a constructor
de: nicht-statisches const-Element %q+#D in Klasse ohne einen Konstruktor

en: non-static data member %qD has Java class type
de: nicht-statisches Datenelement %qD hat Java-Klassentyp

en: non-static data member %qE declared %<constexpr%>
de: nicht-statisches Datenelement %qE als %<constexpr%> deklariert

en: non-static data member initializers
de: Initialisierung nicht-statischer Datenelemente

en: non-static declaration of %q+D follows static declaration
de: Nicht-statische Deklaration von %q+D folgt statischer Deklaration

en: non-static initialization of a flexible array member
de: nicht-statische Initialisierung eines flexiblen Feldelements

en: non-static method %q+D overrides static method
de: nicht-statische Methode %q+D überschreibt statische Methode

en: non-static reference %q+#D in class without a constructor
de: nicht-statische Referenz %q+#D in Klasse ohne Konstruktor

en: non-static reference member %q#D, can%'t use default assignment operator
de: nicht-statisches Referenzelement %q#D, Standard-Zuweisungsoperator kann nicht verwendet werden

en: non-template %qD used as template
de: Nicht-Template %qD als Template verwendet

en: non-template type %qT used as a template
de: Nicht-Template-Typ %qT als Template verwendet

en: non-thread-local declaration of %q#D follows thread-local declaration
de: Nicht-Thread-lokale Deklaration von %q#D folgt Thread-lokaler Deklaration

en: non-thread-local declaration of %q+D follows thread-local declaration
de: Nicht-Thread-lokale Deklaration von %q+D folgt Thread-lokaler Deklaration

en: non-trivial conversion at assignment
de: nicht-triviale Umwandlung bei Zuweisung

en: non-trivial conversion in unary operation
de: nicht-triviale Umwandlung in unärer Operation

en: non-trivial designated initializers not supported
de: nicht-trivial markierte Initialisierungen nicht unterstützt

en: nonconstant array index in initializer
de: nichtkonstanter Feldindex in Initialisierung

en: nonempty exits list of loop %d, but exits are not recorded
de: Nichtleere Ausgangsliste der Schleife %d, aber Ausgänge werden nicht aufgezeichnet

en: nonlocal label
de: nichtlokale Marke

en: nonnull argument has invalid operand number (argument %lu)
de: Nicht-Null-Argument hat ungültige Operandenzahl (Argument %lu)

en: nonnull argument references non-pointer operand (argument %lu, operand %lu)
de: Nicht-Null-Argument referenziert Nicht-Zeiger-Operanden (Argument %lu, Operand %lu)

en: nonnull argument with out-of-range operand number (argument %lu, operand %lu)
de: Nicht-Null-Argument mit Operandenzahl außerhalb des Wertebereiches (Argument %lu, Operand %lu)

en: nonnull attribute without arguments on a non-prototype
de: Nicht-Null-Attribut ohne Argumente für einen Nicht-Prototyp

en: not a valid Java .class file
de: keine gültige Java-.class-Datei

en: not configured for ABI: '%s'
de: nicht für ABI konfiguriert: »%s«

en: not configured with sysroot headers suffix
de: nicht mit sysroot-Header-Suffix konfiguriert

en: not enough arguments
de: Nicht genug Argumente

en: not enough arguments to function %qE
de: Zu wenige Argumente für Funktion %qE

en: not enough collapsed for loops
de: zu wenig zusammengefallen für Schleifen

en: not enough perfectly nested loops
de: nicht genügend perfekt geschachtelte Schleifen

en: not enough type information
de: zu wenig Typinformationen

en: not enough values in return statement
de: nicht genügend Werte in Rückgabeanweisung

en: not enough variable arguments to fit a sentinel
de: Zu wenige variable Argumente, um zu einem Wächter zu passen

en: note:
de: Anmerkung:

en: null argument where non-null required (argument %lu)
de: Null-Argument, wo Nicht-Null erwartet (Argument %lu)

en: null pointer
de: Null-Zeiger

en: num_threads expression must be integral
de: num_threads-Ausdruck muss bestimmt sein

en: number must be 0 or 1
de: Zahl muss 0 oder 1 sein

en: number of arguments doesn%'t match built-in prototype
de: Anzahl der Argumente passt nicht zum eingebauten Prototypen

en: number of arguments doesn%'t match prototype
de: Anzahl der Argumente passt nicht zum Prototypen

en: number of bb notes in insn chain (%d) != n_basic_blocks (%d)
de: Anzahl der bb-Vermerke in Befehlskette (%d) != n_basic_blocks (%d)

en: number of components of the vector not a power of two
de: Komponentenanzahl des Vektors ist keine Zweierpotenz

en: number of counters is %d instead of %d
de: Zahl der Zähler ist %d statt %d

en: number of operands and imm-links don%'t agree in statement
de: Anzahl der Operanden und IMM-Verknüpfungen widersprechen sich in Anweisung

en: number of results does not match number of values
de: Anzahl der Ergebnisse passt nicht zur Anzahl der Werte

en: number of statements in the OpenScop file does not match the graphite internal statements number
de: Anzahl der Anweisungen in der OpenScop-Datei passt nicht zur internen Graphite-Anweisungsanzahl

en: objc++-cpp-output is deprecated; please use objective-c++-cpp-output instead
de: objc++-cpp-output ist veraltet; bitte stattdessen objective-c++-cpp-output verwenden

en: objc-cpp-output is deprecated; please use objective-c-cpp-output instead
de: objc-cpp-output ist veraltet; bitte stattdessen objective-c-cpp-output verwenden

en: object argument is not a potential constant expression
de: Objektargument ist kein potentieller konstanter Ausdruck

en: object is not a method
de: Objekt ist keine Methode

en: object missing in use of %qE
de: bei Verwendung von %qE fehlt Objekt

en: object type %qT does not match destructor name ~%qT
de: Objekttyp %qT passt nicht zum Destruktornamen ~%qT

en: object with variably modified type must have no linkage
de: Objekt mit variabel geändertem Typ darf keine Bindung haben

en: objective-c method declaration is expected
de: Methodendeklaration in Objective-C erwartet

en: objective-c++ message argument(s) are expected
de: Objective-C++ Nachrichtenargument(e) erwartet

en: objective-c++ method declaration is expected
de: Objective-C++ Methodendeklaration erwartet

en: obsolete option -I- used, please use -iquote instead
de: veraltete Option -I- verwendet, bitte stattdessen -iquote verwenden

en: obsolete use of designated initializer with %<:%>
de: veraltete Verwendung einer bestimmten Initialisierung mit %<:%>

en: obsolete use of designated initializer without %<=%>
de: veraltete Verwendung einer bestimmten Initialisierung ohne %<=%>

en: offset of %q+D is not ABI-compliant and may change in a future version of GCC
de: Versatz von %q+D ist ABI-unverträglich und kann sich in zukünftigen GCC-Versionen ändern

en: offset of empty base %qT may not be ABI-compliant and maychange in a future version of GCC
de: Versatz der leeren Basis %qT könnte ABI-unverträglich sein und sich in zukünftigen GCC-Versionen ändern

en: offset of packed bit-field %qD has changed in GCC 4.4
de: Offset des gepackten Bitfeldes %qD hat sich in GCC 4.4 geändert

en: offset of virtual base %qT is not ABI-compliant and may change in a future version of GCC
de: Versatz der virtuellen Basis %qT ist ABI-unverträglich und kann sich in zukünftigen GCC-Versionen ändern

en: offset outside bounds of constant string
de: Adressabstand ist außerhalb der Grenzen der konstanten Zeichenkette

en: old-style function definition
de: Funktionsdefinition im alten Stil

en: old-style parameter declarations in prototyped function definition
de: Parameterdeklarationen alten Stils in Prototyp-Funktionsdeklaration

en: omitted middle operand to %<?:%> operand cannot be mangled
de: ausgelassener mittlerer Operand für Operator %<?:%> kann nicht verarbeitet werden

en: only 0.0 can be loaded as an immediate
de: nur 0.0 kann als Immediate geladen werden

en: only Objective-C object types can be qualified with a protocol
de: nur Objective-C-Objekttypen können mit Protokoll qualifiziert werden

en: only constructors take member initializers
de: nur Konstruktoren nehmen Elementinitialisierungen

en: only declarations of constructors can be %<explicit%>
de: nur Deklarationen von Konstruktoren können %<explicit%> sein

en: only initialized variables can be placed into program memory area
de: Nur initialisierte Variablen können im Programmspeicherbereich platziert werden

en: only one -flto-partition value can be specified
de: für -flto-partition kann nur ein Wert angegeben werden

en: only one of -mm and -ml may be given
de: nur eines von -mm und -ml darf angegeben werden

en: only one of -mm and -mtiny= may be given
de: nur eines von -mm und -mtiny= darf angegeben werden

en: only one of -ms and -ml may be given
de: nur eines von -ms und -ml darf angegeben werden

en: only one of -ms and -mm may be given
de: nur eines von -ms und -mm darf angegeben werden

en: only one of -ms and -mtiny= may be given
de: nur eines von -ms und -mtiny= darf angegeben werden

en: only uninitialized variables can be placed in a .bss section
de: Nur uninitialisierte Variablen können in einem .bss-Abschnitt platziert werden

en: only uninitialized variables can be placed in the .noinit section
de: Nur uninitialisierte Variablen können im .noinit-Bereich platziert werden

en: only weak aliases are supported in this configuration
de: in dieser Konfiguration werden nur schwache Aliase unterstützt

en: opaque vector types cannot be initialized
de: opake Vektortypen können nicht initialisiert werden

en: opaque-enum-specifier must use a simple identifier
de: intransparente Enum-Spezifikation muss einfachen Bezeichner verwenden

en: opaque-enum-specifier without name
de: intransparente Enum-Spezifikation ohne Namen

en: open /dev/zero: %m
de: /dev/zero öffnen: %m

en: opening dependency file %s: %m
de: Abhängigkeitsdatei »%s« wird geöffnet: %m

en: opening output file %s: %m
de: Ausgabedatei »%s« wird geöffnet: %m

en: opening output file %s: %s
de: Ausgabedatei »%s« wird geöffnet: %s

en: operand 1 must be a hard register
de: erster Operand muss ein hartes Register sein

en: operand constraint contains incorrectly positioned %<+%> or %<=%>
de: Operandenbedingung enthält falsch positioniertes %<+%> oder %<=%>

en: operand constraints for %<asm%> differ in number of alternatives
de: Operandenbedingungen für %<asm%> unterscheiden sich in der Anzahl der Alternativen

en: operand is neither a constant nor a condition code, invalid operand code 'C'
de: Operand ist weder eine Konstante noch ein Bedingungscode, ungültiger Operandencode »C«

en: operand is neither a constant nor a condition code, invalid operand code 'F'
de: Operand ist weder eine Konstante noch ein Bedingungscode, ungültiger Operandencode »F«

en: operand is neither a constant nor a condition code, invalid operand code 'c'
de: Operand ist weder eine Konstante noch ein Bedingungscode, ungültiger Operandencode »c«

en: operand is neither a constant nor a condition code, invalid operand code 'f'
de: Operand ist weder eine Konstante noch ein Bedingungscode, ungültiger Operandencode »f«

en: operand is not a condition code, invalid operand code 'D'
de: Operand ist kein Bedingungscode, ungültiger Operandencode »D«

en: operand is not a condition code, invalid operand code 'Y'
de: Operand ist kein Bedingungscode, ungültiger Operandencode »Y«

en: operand number missing after %%-letter
de: Operandenzahl fehlt hinter %%-Buchstabe

en: operand number out of range
de: Operandenzahl außerhalb des Wertebereiches

en: operand number out of range in format
de: Operandennummer außerhalb des Wertebereiches im Format

en: operand number specified for format taking no argument
de: Operandennummer für Format ohne Argumente angegeben

en: operand number specified with suppressed assignment
de: Operandennummer mit unterdrückter Zuweisung angegeben

en: operands to ?: have different types %qT and %qT
de: Operanden für ?: haben verschiedene Typen: %qT und %qT

en: operation on %qE may be undefined
de: Operation auf %qE könnte undefiniert sein

en: optimization may eliminate reads and/or writes to register variables
de: Optimierung kann Lese- und/oder Schreiboperationen auf Registervariablen entfernen

en: optimization options not supported yet
de: Optimierungsoptionen werden noch nicht unterstützt

en: optimizing for size and code size would grow
de: bei Optimierung nach Größe würde Codegröße wachsen

en: option("%s") was already specified
de: option("%s") wurde bereits spezifiziert

en: options enabled:
de: angeschaltete Optionen:

en: options passed:
de: angegebene Optionen:

en: ordered comparison of pointer with integer zero
de: geordneter Vergleich von Zeiger mit Ganzzahlnull

en: ordered comparison of pointer with null pointer
de: geordneter Vergleich von Zeiger mit Null-Zeiger

en: ordered region may not be closely nested inside of critical or explicit task region
de: geordnete Region darf nicht innerhalb kritischer oder »explicit task«-Region eng geschachtelt sein

en: ordered region must be closely nested inside a loop region with an ordered clause
de: geordnete Region muss innerhalb einer Schleifenregion mit geordneter Klausel eng geschachtelt sein

en: original definition appeared here
de: ursprüngliche Definition trat hier auf

en: original type declared here
de: ursprünglicher Typ hier deklariert

en: originally defined here
de: ursprünglich hier definiert

en: originally indirect function call not considered for inlining
de: ursprünglich indirekter Funktionsaufruf kommt nicht als »inline« in Betracht

en: out of memory
de: Platz im Hauptspeicher reicht nicht aus

en: outer block of region %i is wrong
de: äußerer Block der Region %i ist falsch

en: output constraint %d cannot be specified together with "%s" clobber
de: Ausgabebedingung %d kann nicht zusammen mit »%s« angegeben werden

en: output constraint %d must specify a single register
de: Ausgabebedingung %d muss ein einzelnes Register angeben

en: output constraint %qc for operand %d is not at the beginning
de: Ausgabebedingung %qc für Operand %d steht nicht am Anfang

en: output error when writing state file %s [%s]
de: Ausgabefehler beim Schreiben der Zustandsdatei %s [%s]

en: output filename specified twice
de: Ausgabedatei doppelt angegeben

en: output number %d not directly addressable
de: Ausgabezahl %d nicht direkt adressierbar

en: output operand %d must use %<&%> constraint
de: Ausgabeoperand %d muss %<&%>-Bedingung verwenden

en: output operand constraint lacks %<=%>
de: Bedingung des Ausgabeoperanden erfordert %<=%>

en: output operand is constant in %<asm%>
de: Ausgabeoperand ist in %<asm%> konstant

en: output regs must be grouped at top of stack
de: Ausgaberegister müssen oben auf dem Stack gruppiert werden

en: overflow in array dimension
de: Überlauf in Feldgröße

en: overflow in constant expression
de: Überlauf in Konstanten-Ausdruck

en: overflow in enumeration values
de: Überlauf in Aufzählungswerten

en: overflow in enumeration values at %qD
de: Überlauf in Aufzählungswerten bei %qD

en: overflow in implicit constant conversion
de: Überlauf in impliziter Konstantenkonvertierung

en: overloaded function with no contextual type information
de: überladene Funktion ohne Typinformationen aus Kontext

en: overriding deleted function %q+D
de: gelöschte Funktion %q+D aufgehoben

en: overriding non-deleted function %q+D
de: nicht gelöschte Funktion %q+D aufgehoben

en: packed attribute causes inefficient alignment
de: gepacktes Attribut führt zu ineffizienter Ausrichtung

en: packed attribute causes inefficient alignment for %q+D
de: gepacktes Attribut verursacht ineffiziente Ausrichtung für %q+D

en: packed attribute causes inefficient alignment for %qE
de: gepacktes Attribut verursacht ineffiziente Ausrichtung für %qE

en: packed attribute is unnecessary
de: gepacktes Attribut ist unnötig

en: packed attribute is unnecessary for %q+D
de: gepacktes Attribut ist unnötig für %q+D

en: packed attribute is unnecessary for %qE
de: gepacktes Attribut ist für %qE unnötig

en: padding struct size to alignment boundary
de: struct wird bis zur Ausrichtungsgrenze aufgefüllt

en: padding struct to align %q+D
de: struct wird aufgefüllt, um %q+D auszurichten

en: parameter %P has incomplete type %qT
de: Parameter %P hat unvollständigen Typen %qT

en: parameter %P of %qD has incomplete type %qT
de: Parameter %P von %qD hat unvollständigen Typen %qT

en: parameter %q+D declared %<inline%>
de: Parameter %q+D als %<inline%> deklariert

en: parameter %q+D has just a forward declaration
de: Parameter %q+D hat nur eine Vorwärtsdeklaration

en: parameter %q+D set but not used
de: Parameter %q+D gesetzt, aber nicht verwendet

en: parameter %qD declared void
de: Parameter %qD leer definiert

en: parameter %qD declared with void type
de: Parameter %qD als void deklariert

en: parameter %qD has Java class type
de: Parameter %qD hat Java-Klassentyp

en: parameter %qD has incomplete type
de: Parameter %qD hat unvollständigen Typen

en: parameter %qD includes pointer to array of unknown bound %qT
de: Parameter %qD bezieht Zeiger auf Feld mit unbekannter Grenze %qT ein

en: parameter %qD includes reference to array of unknown bound %qT
de: Parameter %qD bezieht Referenz auf Feld mit unbekannter Grenze %qT ein

en: parameter %qD invalidly declared method type
de: Parameter %qD deklariert ungültigerweise Methodentyp

en: parameter %qD is initialized
de: Parameter %qD ist initialisiert

en: parameter %qD set but not used
de: Parameter %qD gesetzt, jedoch nicht verwendet

en: parameter %qP of %qD might be a candidate for a format attribute
de: Parameter %qP von %qD könnte Kandidat für Formatattribut sein

en: parameter %u (%q+D) has incomplete type
de: Parameter %u (%q+D) hat unvollständigen Typen

en: parameter %u (%q+D) has void type
de: Parameter %u (%q+D) hat void-Typen

en: parameter %u has incomplete type
de: Parameter %u hat unvollständigen Typen

en: parameter %u has void type
de: Parameter %u hat void-Typen

en: parameter declared %<auto%>
de: Parameter als %<auto%> deklariert

en: parameter list does not match a valid signature for %s()
de: Parameterliste passt zu keiner gültigen Signatur für %s()

en: parameter may not have variably modified type %qT
de: Parameter darf nicht variabel modifizierten Typ %qT haben

en: parameter might be a candidate for a format attribute
de: Parameter könnte ein Kandidat für ein Formatattribut sein

en: parameter name missing from parameter list
de: Parametername fehlt in Parameterliste

en: parameter name omitted
de: Parametername ausgelassen

en: parameter names (without types) in function declaration
de: Parameternamen (ohne Typen) in Funktionsdeklaration

en: parameter pack %qE must be at the end of the template parameter list
de: Parameterpack %qE muss am Ende der Templateparameterliste sein

en: parameter pack %qT must be at the end of the template parameter list
de: Parameterpack %qT muss am Ende der Templateparameterliste sein

en: parameter pack argument %qE must be at the end of the template argument list
de: Argument %qE für Parameterpack muss am Ende der Templateargumentliste sein

en: parameter pack argument %qT must be at the end of the template argument list
de: Argument %qT für Parameterpack muss am Ende der Templateargumentliste sein

en: parameter packs not expanded with %<...%>:
de: Parameterbündel nicht mit %<...%> aufgelöst:

en: parameters number in the scop file is different from the internal scop parameter number
de: Anzahl der Parameter in der Scop-Datei unterscheidet sich von der internen Anzahl der Scop-Parameter

en: parentheses around %qE cannot be used to form a pointer-to-member-function
de: Klammern um %qE können nicht verwendet werden, einen Zeiger auf Elementfunktion zu erzeugen

en: parenthesized initialization is not allowed in OpenMP %<for%> loop
de: geklammerte Initialisierung ist in OpenMP-%<for%>-Schleife nicht erlaubt

en: parse error in template argument list
de: Syntaxfehler in Templateargumentliste

en: partial specialization %qT declared %<friend%>
de: Teilspezialisierung %qT als %<friend%> deklariert

en: partial specialization %qT does not specialize any template arguments
de: Teilspezialisierung %qT spezialisiert keine Templateargumente

en: partial specialization of %qT after instantiation of %qT
de: teilweise Spezialisierung von %qT hinter Instanziierung von %qT

en: pass %qs not found but is referenced by new pass %qs
de: Durchlauf %qs nicht gefunden, wird jedoch von neuem Durchlauf %qs referenziert

en: passing %qT as %<this%> argument of %q#D discards qualifiers
de: Die Übergabe von %qT als %<this%>-Argument von %q#D streicht Qualifizierer

en: passing %qT chooses %qT over %qT
de: Übergabe von %qT wählt %qT statt %qT

en: passing NULL to non-pointer argument %P of %qD
de: Übergabe von NULL an Nicht-Zeiger-Argument %P von %qD

en: passing arg %d of %qE discards qualifiers frompointer target type
de: Übergabe des Arguments %d von %qE entfernt Kennzeichner von Zeiger-Ziel-Typ

en: passing argument %d of %qE as %<float%> rather than %<double%> due to prototype
de: Übergabe des Arguments %d von %qE als %<float%> statt %<double%> aufgrund des Prototyps

en: passing argument %d of %qE as %qT rather than %qT due to prototype
de: Übergabe des Arguments %d von %qE als %qT statt %qT aufgrund des Prototyps

en: passing argument %d of %qE as complex rather than floating due to prototype
de: Übergabe des Arguments %d von %qE als komplex statt Gleitkomma aufgrund des Prototyps

en: passing argument %d of %qE as complex rather than integer due to prototype
de: Übergabe des Arguments %d von %qE als komplex statt Ganzzahl aufgrund des Prototyps

en: passing argument %d of %qE as floating rather than complex due to prototype
de: Übergabe des Arguments %d von %qE als Gleitkomma statt komplex aufgrund des Prototyps

en: passing argument %d of %qE as floating rather than integer due to prototype
de: Übergabe des Arguments %d von %qE als Gleitkomma statt Ganzzahl aufgrund des Prototyps

en: passing argument %d of %qE as integer rather than complex due to prototype
de: Übergabe des Arguments %d von %qE als Ganzzahl statt komplex aufgrund des Prototyps

en: passing argument %d of %qE as integer rather than floating due to prototype
de: Übergabe des Arguments %d von %qE als Ganzzahl statt Gleitkomma aufgrund des Prototyps

en: passing argument %d of %qE as signed due to prototype
de: Übergabe des Arguments %d von %qE als vorzeichenbehaftet aufgrund des Prototyps

en: passing argument %d of %qE as unsigned due to prototype
de: Übergabe des Arguments %d von %qE als vorzeichenlos aufgrund des Prototyps

en: passing argument %d of %qE discards %qv qualifier from pointer target type
de: Übergabe des Arguments %d von %qE entfernt Kennzeichner %qv von Zeiger-Ziel-Typ

en: passing argument %d of %qE from distinct Objective-C type
de: Übergabe des Arguments %d von %qE von anderem Objective-C-Typ

en: passing argument %d of %qE from incompatible pointer type
de: Übergabe des Arguments %d von %qE von inkompatiblem Zeigertyp

en: passing argument %d of %qE from pointer to non-enclosed address space
de: Übergabe des Arguments %d von %qE von Zeiger auf nicht eingeschlossenen Adressbereich

en: passing argument %d of %qE makes %q#v qualified function pointer from unqualified
de: Übergabe des Arguments %d von %qE erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: passing argument %d of %qE makes integer from pointer without a cast
de: Übergabe des Arguments %d von %qE  erzeugt Ganzzahl von Zeiger ohne Typkonvertierung

en: passing argument %d of %qE makes pointer from integer without a cast
de: Übergabe des Arguments %d von %qE erzeugt Zeiger von Ganzzahl ohne Typkonvertierung

en: passing argument %d of %qE with different width due to prototype
de: Übergabe des Arguments %d von %qE mit anderer Breite aufgrund des Prototyps

en: passing floating point arguments in fp regs not yet supported
de: Die Übergabe von Gleitkommaargumenten in FP-Registern wird noch nicht unterstützt

en: pc%d is not valid precision setting (32, 64 or 80)
de: pc%d ist kein gültiger Präzisionswert (32, 64 oder 80)

en: pch_preprocess pragma should only be used with -fpreprocessed
de: pch_preprocess-Pragma sollte nur mit -fpreprocessed verwendet werden

en: pedwarn:
de: Ped. Warnung:

en: permerror:
de: Perm. Fehler:

en: pex_init failed
de: pex_init gescheitert

en: pex_init failed: %m
de: pex_init gescheitert: %m

en: picochip_asm_output_opcode - Found multiple lines in VLIW packet %s
de: picochip_asm_output_opcode - Mehrere Zeilen in VLIW-Paket %s gefunden

en: picochip_asm_output_opcode - can%'t output unknown operator %c
de: picochip_asm_output_opcode - unbekannter Operator %c kann nicht ausgegeben werden

en: plugin %s is not licensed under a GPL-compatible license
    %s
de: Plugin %s ist nicht unter einer GPL-kompatiblen Lizenz lizenziert
    %s

en: plugin %s registered a null callback function for event %s
de: Plugin %s hat eine Null-Callback-Funktion für Ereignis %s registriert

en: plugin %s should be specified before -fplugin-arg-%s in the command line
de: Plugin %s sollte vor -fplugin-arg-%s in der Kommandozeile angegeben werden

en: plugin %s was specified with different paths:
    %s
    %s
de: Plugin %s wurde mit anderen Pfaden angegeben:
    %s
    %s

en: plugin cannot register a missing pass
de: Plugin kann keinen fehlenden Durchlauf registrieren

en: plugin cannot register an unnamed pass
de: Plugin kann keinen unbenannten Durchlauf registrieren

en: plugin cannot register pass %qs without reference pass name
de: Plugin kann keinen Durchlauf %qs ohne Referenzdurchlaufnamen registrieren

en: plugin support is disabled; configure with --enable-plugin
de: Plugin-Unterstützung ist ausgeschaltet; mit --enable-plugin konfigurieren

en: pointer arithmetic for garbage-collected objects not allowed
de: Zeigerarithmetik für Objekte mit Garbage-Collection ist nicht erlaubt

en: pointer assignment
de: Zeigerzuweisung

en: pointer comparison expression is not a constant expression
de: Zeigervergleichsausdruck ist kein konstanter Ausdruck

en: pointer of type %<void *%> used in arithmetic
de: Zeiger auf Typen %<void *%> in Arithmetik verwendet

en: pointer of type %<void *%> used in subtraction
de: Zeiger des Typs %<void *%> in Subtraktion verwendet

en: pointer target types incompatible in C++
de: Zeiger-Zieltypen sind in C++ inkompatibel

en: pointer targets in assignment differ in signedness
de: Zeigerziele in Zuweisung unterscheiden sich im Vorzeichenbesitz

en: pointer targets in initialization differ in signedness
de: Zeigerziele in Initialisierung unterscheiden sich im Vorzeichenbesitz

en: pointer targets in passing argument %d of %qE differ in signedness
de: Zeigerziele bei Übergabe des Arguments %d von %qE unterscheiden sich im Vorzeichenbesitz

en: pointer targets in return differ in signedness
de: Zeigerziele in return unterscheiden sich im Vorzeichenbesitz

en: pointer to a function used in arithmetic
de: Zeiger auf Funktion in Arithmetik verwendet

en: pointer to a function used in subtraction
de: Zeiger auf eine Funktion in Subtraktion verwendet

en: pointer to interface type has no methods
de: Zeiger auf Schnittstellentyp hat keine Methoden

en: pointer to member conversion via virtual base %qT
de: Umwandlung in Zeiger auf Element über virtuelle Basis %qT

en: pointer to member function used in arithmetic
de: Zeiger auf Elementfunktion in Arithmetik verwendet

en: pointer to member type %qT incompatible with object type %qT
de: Zeiger auf Elementtyp %qT mit Objekttyp %qT inkompatibel

en: pointer type mismatch in conditional expression
de: Zeigertyp passt nicht in bedingtem Ausdruck

en: pointer value used where a complex was expected
de: Zeigerwert verwendet, wo »complex« erwartet wurde

en: pointer value used where a floating point value was expected
de: Zeigerwert verwendet, wo Gleitkommawert erwartet wurde

en: pointer-to-member function %E cannot be called without an object; consider using .* or ->*
de: Zeiger auf Elementfunktion %E kann nicht ohne Objekt aufgerufen werden; Beispiele: .* oder ->*

en: pointer/integer type mismatch in conditional expression
de: Zeiger-/Ganzzahltyp passt nicht in bedingtem Ausdruck

en: pointers are not permitted as case values
de: Zeiger sind nicht als case-Werte zugelassen

en: pointers to disjoint address spaces used in conditional expression
de: Zeiger auf disjunkte Adressräume in bedingtem Ausdruck verwendet

en: possible problem detected in invocation of delete operator:
de: mögliches Problem bei Aufruf des »delete«-Operators erkannt

en: post-increment address is not a register
de: Post-Increment-Adresse ist kein Register

en: postfix %qD must take %<int%> as its argument
de: Suffix-%qD muss %<int%> als sein Argument nehmen

en: postfix %qD must take %<int%> as its second argument
de: Suffix-%qD muss %<int%> als sein zweites Argument nehmen

en: postfix %qD should return %qT
de: Suffix-%qD sollte %qT zurückgeben

en: pre-decrement address is not a register
de: Pre-Decrement-Adresse ist kein Register

en: pre-increment address is not a register
de: Pre-Increment-Adresse ist kein Register

en: precision
de: Genauigkeit

en: precision in printf format
de: Genauigkeit im printf-Format

en: predicated Thumb instruction
de: angegebene Thumb-Anweisung

en: predicated instruction in conditional sequence
de: angegebene Anweisung in bedingter Sequenz

en: prefix %qD should return %qT
de: Präfix-%qD sollte %qT zurückgeben

en: prefix attributes are ignored before %<@%D%>
de: Präfix-Attribute vor %<@%D%> werden ignoriert

en: prefix attributes are ignored for implementations
de: Präfixattribute werden für Implementierungen ignoriert

en: prefix attributes are ignored for methods
de: Präfixattribute werden für Methoden ignoriert

en: prev_bb of %d should be %d, not %d
de: prev_bb von %d sollte %d sein, nicht %d

en: previous declaration
de: vorherige Deklaration

en: previous declaration %q+#D here
de: vorherige Deklaration %q+#D hier

en: previous declaration %q+D
de: vorherige Deklaration %q+D

en: previous declaration %q+D used %d template parameter | previous declaration %q+D used %d template parameters
de[0]: vorherige Deklaration %q+D verwendete %d Template-Parameter
de[1]: vorherige Deklaration %q+D verwendete %d Template-Parameter

en: previous declaration of %<%c%E%>
de: vorherige Deklaration von %<%c%E%>

en: previous declaration of %<%c%E%> as %<@optional%>
de: vorherige Deklaration von %<%c%E%> als %<@optional%>

en: previous declaration of %<%c%E%> as %<@required%>
de: vorherige Deklaration von %<%c%E%> als %<@required%>

en: previous declaration of %<%c%s%>
de: vorherige Deklaration von %<%c%s%>

en: previous declaration of %q+#D
de: vorherige Deklaration von %q+#D

en: previous declaration of %q+#D with %qL linkage
de: vorherige Deklaration von %q+#D mit %qL-Bindung

en: previous declaration of %q+D
de: vorherige Deklaration von %q+D

en: previous declaration of %q+D was here
de: Vorherige Deklaration von %q+D war hier

en: previous declaration of %q+D was inline
de: vorherige Deklaration von %q+D war inline

en: previous declaration of %q+D with attribute noinline
de: vorherige Deklaration von %q+D mit Attribut noinline

en: previous declaration of %qE
de: vorherige Deklaration von %qE

en: previous declaration of namespace %q+D here
de: vorherige Deklaration von namespace %q+D hier

en: previous definition here
de: vorherige Definition hier

en: previous definition of %q+#T
de: vorherige Definition von %q+#T

en: previous definition of %q+D was here
de: Vorherige Definition von %q+D war hier

en: previous external decl of %q+#D
de: vorherige externe Deklaration von %q+#D

en: previous implicit declaration of %q+D was here
de: Vorherige implizite Deklaration von %q+D war hier

en: previous non-function declaration %q+#D
de: vorherige Deklaration %q+#D einer Nicht-Funktion

en: previously declared here
de: vorher hier deklariert

en: previously defined here
de: vorher hier definiert

en: previously used here
de: Bereits hier verwendet

en: private member %q+#D in anonymous struct
de: privates Element %q+#D in anonymer struct

en: private member %q+#D in anonymous union
de: privates Element %q+#D in anonymer Union

en: profiler support for CRX
de: Profilerunterstützung für CRX

en: profiler support for VxWorks
de: Profilerunterstützung für VxWorks

en: profiling not supported with -mg
de: Profiling wird mit -mg nicht unterstützt

en: programs: %s
de: Programme: %s

en: promoted argument %qD doesn%'t match built-in prototype
de: weitergegebenes Argument %qD passt nicht zu eingebautem Prototypen

en: promoted argument %qD doesn%'t match prototype
de: weitergegebenes Argument %qD passt nicht zum Prototypen

en: promoted ~unsigned is always non-zero
de: weitergegebenes ~vorzeichenlos ist immer Nicht-Null

en: property %qs already specified in %<@dynamic%>
de: Eigenschaft %qs ist bereits in %<@dynamic%> festgelegt

en: property %qs already specified in %<@synthesize%>
de: Eigenschaft %qs ist bereits in %<@synthesize%> festgelegt

en: property %qs is using instance variable %qs of incompatible type
de: Eigenschaft %qs verwendet Instanzvariable %qs unverträglichen Typs

en: property %qs is using the same instance variable as property %qs
de: Eigenschaft %qs verwendet die selbe Instanzvariable wie die Eigenschaft %qs

en: protected member %q+#D in anonymous struct
de: geschütztes Element %q+#D in anonymer struct

en: protected member %q+#D in anonymous union
de: geschütztes Element %q+#D in anonymer Union

en: protocol %qE has circular dependency
de: Protokoll %qE hat ringförmige Abhängigkeit

en: protocol %qE is deprecated
de: Protokoll %qE ist veraltet

en: prototype declaration
de: Prototyp-Deklaration

en: prototype for %q#D does not match any in class %qT
de: Prototyp für %q#D passt zu nichts in Klasse %qT

en: prototype for %q+#D
de: Prototyp für %q+#D

en: prototype for %q+D declares argument %d with incompatible type
de: Prototyp für %q+D deklariert Argument %d mit inkompatiblem Typen

en: prototype for %q+D declares fewer arguments than previous old-style definition
de: Prototyp für %q+D deklariert weniger Argumente als vorherige Definition im alten Stil

en: prototype for %q+D declares more arguments than previous old-style definition
de: Prototyp für %q+D deklariert mehr Argumente als vorherige Definition im alten Stil

en: prototype for %q+D follows non-prototype definition
de: Prototyp für %q+D folgt einer Nicht-Prototyp-Definition

en: provided for %q+D
de: für %q+D bereitgestellt

en: pseudo-destructor is not called
de: Pseudo-Destruktor wird nicht aufgerufen

en: pure-specifier on function-definition
de: reiner Spezifizierer bei Funktionsdefinition

en: qualified function types cannot be used to declare free functions
de: qualifizierte Funktionstypen können nicht verwendet werden, um free-Funktionen zu deklarieren

en: qualified function types cannot be used to declare static member functions
de: qualifizierte Funktionstypen können nicht verwendet werden, um statische Elementfunktionen zu deklarieren

en: qualified name does not name a class
de: qualifizierter Name benennt keine Klasse

en: qualified type %qT does not match destructor name ~%qT
de: qualifizierter Typ %qT passt nicht zum Destruktornamen ~%qT

en: qualifiers are not allowed on declaration of %<operator %T%>
de: Qualifizierer sind bei Deklaration von %<operator %T%> nicht erlaubt

en: qualifiers can only be specified for objects and functions
de: Qualifizierer können nur für Objekte und Funktionen angegeben werden

en: qualifying type %qT does not match destructor name ~%qT
de: qualifizierender Typ %qT passt nicht zum Destruktornamen ~%qT

en: r0 needs to be available as a call-clobbered register
de: r0 muss als aufrufzerstörtes Register verfügbar sein

en: range clause must have array, slice, setring, map, or channel type
de: Bereichsklausel muss Feld, Scheibe, Setring, Abbildung oder Kanaltyp haben

en: range expressions in switch statements are non-standard
de: Wertebereichsausdrücke in switch-Anweisungen sind nicht standardkonform

en: range-based-for loops are not allowed in C++98 mode
de: bereichsbasierte for-Schleifen sind im C++98-Modus nicht erlaubt

en: read-only location %qE used as %<asm%> output
de: schreibgeschützte Stelle %qE als %<asm%>-Ausgabe verwendet

en: read-only member %qD used as %<asm%> output
de: schreibgeschütztes Element %qD als %<asm%>-Ausgabe verwendet

en: read-only named return value %qD used as %<asm%>output
de: schreibgeschützter benannter Rückgabewert %qD als %<asm%>-Ausgabe verwendet

en: read-only parameter %qD use as %<asm%> output
de: schreibgeschützter Parameter %qD als %<asm%>-Ausgabe verwendet

en: read-only reference %qD used as %<asm%> output
de: schreibgeschützte Referenz %qD als %<asm%>-Ausgabe verwendet

en: read-only variable %qD used as %<asm%> output
de: schreibgeschützte Variable %qD als %<asm%>-Ausgabe verwendet

en: reading class %s for the second time from %s
de: Lesen der Klasse %s zu zweiten Mal von %s

en: reading through null pointer (argument %d)
de: Lesen über Null-Zeiger (Argument %d)

en: readonly property can not be set
de: schreibgeschützte Eigenschaft kann nicht gesetzt werden

en: real kind=8 not available for -fdefault-real-8 option
de: real kind=8 nicht verfügbar für Option -fdefault-real-8

en: recompiling with -fcompare-debug
de: Neuübersetzung mit -fcompare-debug

en: recursive evaluation of default argument for %q#D
de: rekursive Auswertung des Standardarguments für %q#D

en: recursive inlining
de: rekursives Inlining

en: recursive type %qT undefined
de: rekursiver Typ %qT nicht definiert

en: redeclaration %qD differs in %<constexpr%>
de: Redeklaration %qD unterscheidet sich in %<constexpr%>

en: redeclaration of %<enum %E%>
de: Redeklaration von %<enum %E%>

en: redeclaration of %<wchar_t%> as %qT
de: Redeklaration von %<wchar_t%> als %qT

en: redeclaration of %q#D
de: Redeklaration von %q#D

en: redeclaration of %q+D with different visibility (old visibility preserved)
de: Redeklaration von %q+D mit anderer Sichtbarkeit (alte Sichtbarkeit beibehalten)

en: redeclaration of %q+D with no linkage
de: Redeklaration von %q+D ohne Bindung

en: redeclaration of %qT as a non-template
de: Redeklaration von %qT als Nicht-Template

en: redeclaration of C++ built-in type %qT
de: Redeklaration des eingebauten C++-Typs %qT

en: redeclaration of Objective-C class %qs
de: Redeklaration der Objective-C-Klasse %qs

en: redeclaration of enumerator %q+D
de: Redeklaration von Aufzählung %q+D

en: redeclaration of friend %q#D may not have default template arguments
de: Redeklaration des »friend« %q#D kann keine Standardtemplateargumente haben

en: redeclared here as %q#D
de: hier als %q#D redeklariert

en: redeclared with %d template parameter | redeclared with %d template parameters
de[0]: mit %d Template-Parameter redeklariert
de[1]: mit %d Template-Parametern redeklariert

en: redefined extern inline functions are not considered for inlining
de: redefinierte »extern inline«-Funktionen kommen nicht als »inline« in Betracht

en: redefinition of %<struct %E%>
de: Redefinition von %<struct %E%>

en: redefinition of %<union %E%>
de: Redefinition von %<union %E%>

en: redefinition of %q#D
de: Redefinition von %q#D

en: redefinition of %q#T
de: Redefinition von %q#T

en: redefinition of %q+D
de: Redefinition von %q+D

en: redefinition of default argument for %q#D
de: Redefinition des Standardarguments für %q#D

en: redefinition of parameter %q+D
de: Redefinition des Parameters %q+D

en: redefinition of typedef %q+D
de: Redefinition des typedef %q+D

en: redefinition of typedef %q+D with different type
de: Redefinition des typedef %q+D mit anderem Typ

en: redefinition of typedef %q+D with variably modified type
de: Redefinition des typedef %q+D mit variabel modifiziertem Typ

en: redundant redeclaration of %q+D
de: Redundante Redeklaration von %q+D

en: redundant redeclaration of %qD in same scope
de: redundante Redeklaration von %qD im selben Gültigkeitsbereich

en: reference %qs cannot be declared %<mutable%>
de: Referenz %qs kann nicht als %<mutable%> deklariert sein

en: reference %qs is ambiguous: appears in interface %qs and interface %qs
de: Referenz %qs ist mehrdeutig: erscheint in den Schnittstellen %qs und %qs

en: reference to %<%T::%D%> is ambiguous
de: Referenz auf %<%T::%D%> ist mehrdeutig

en: reference to %qD is ambiguous
de: Referenz auf %qD ist mehrdeutig

en: reference to local variable %q+D returned
de: Referenz auf lokale Variable %q+D zurückgegeben

en: reference to non-PURE function '%s' at %L inside a FORALL %s
de: Referenz auf Nicht-PURE-Funktion »%s« bei %L innerhalb eines FORALL %s

en: reference to non-lvalue returned
de: Referenz auf Nicht-L-Wert zurückgegeben

en: region of lp %i is wrong
de: Region von lp %i ist falsch

en: region_array does not match region_tree
de: region_array passt nicht zum region_tree

en: region_array is corrupted for region %i
de: region_array ist für Region %i beschädigt

en: register name given for non-register variable %q+D
de: Registername für Nicht-Registervariable %q+D angegeben

en: register name not specified for %q+D
de: für %q+D wurde kein Registername angegeben

en: register or memory expression expected for 'M' output modifier
de: Register oder Speicherausdruck für Ausgabemodifizierer »M« erwartet

en: register or memory expression expected for 'N' output modifier
de: Register oder Speicherausdruck für Ausgabemodifizierer »N« erwartet

en: register specified for %q+D isn%'t suitable for data type
de: für %q+D angegebenes Register eignet sich nicht für Datentyp

en: register used for two global register variables
de: Register für zwei globale Registervariablen verwendet

en: register variable %qD used in nested function
de: Register-Variable %qD in verschachtelter Funktion verwendet

en: registers IX, IY and Z used in the same INSN
de: Register IX, IY und Z im selben Befehl verwendet

en: regparam and thiscall attributes are not compatible
de: Attribute regparam und thiscall sind nicht verträglich

en: reimplementation of class %qE
de: Reimplementation der Klasse %qE

en: reinterpret_cast from type %qT to type %qT casts away qualifiers
de: reinterpret_cast des Typs %qT in Typ %qT entfernt Qualifizierer

en: removing .rpo file
de: .rpo-Datei wird gelöscht

en: rename spec %s to %s
de: Spezifikation wird von %s nach %s umbenannt

en: renaming .rpo file
de: .rpo-Datei wird umbenannt

en: repeated %<@%> before Objective-C string
de: wiederholtes %<@%> vor Objective-C-Zeichenkette

en: repeated %s in format
de: wiederholtes %s im Format

en: repeated using declaration %q+D
de: Wiederholte using-Deklaration %q+D

en: repository file '%s' does not contain command-line arguments
de: Repository-Datei »%s« enthält keine Kommandozeilenargumente

en: request for implicit conversion from %qT to %qT not permitted in C++
de: Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt

en: request for member %qD in %qE, which is of non-class type %qT
de: Abfrage des Elementes %qD in %qE, das vom Nicht-Klassentyp %qT ist

en: request for member %qD is ambiguous
de: Abfrage des Elementes %qD ist mehrdeutig

en: request for member %qD is ambiguous in multiple inheritance lattice
de: Abfrage des Elementes %qD ist im Gitter der Mehrfachvererbung mehrdeutig

en: request for member %qE in non-class type %qT
de: Abfrage des Elementes %qE in Nicht-Klassentyp %qT

en: request for member %qE in something not a structure or union
de: Anfrage nach Element %qE in etwas, was keine Struktur oder Variante ist

en: requested alignment for %q+D is greater than implemented alignment of %wu
de: angeforderte Ausrichtung für %q+D ist größer als die implementierte Ausrichtung von %wu

en: requested alignment is not a constant
de: Verlangte Ausrichtung ist keine Konstante

en: requested alignment is not a power of 2
de: Verlangte Ausrichtung ist keine Zweierpotenz

en: requested alignment is too large
de: Verlangte Ausrichtung ist zu groß

en: requested init_priority is not an integer constant
de: angefordertes init_priority ist keine Ganzzahlkonstante

en: requested init_priority is out of range
de: angefordertes init_priority ist außerhalb des Wertebereiches

en: requested init_priority is reserved for internal use
de: angefordertes init_priority ist für interne Verwendung reserviert

en: requested position is less than zero
de: Angeforderte Position ist kleiner als Null

en: requested position is not an integer constant
de: Angeforderte Position ist keine Ganzzahlkonstante

en: result of %<operator->()%> yields non-pointer result
de: Ergebnis von %<operator->()%> ergibt Nicht-Zeiger-Ergebnis

en: return discards %qv qualifier from pointer target type
de: return streicht Qualifizierer %qv von Zeiger-Zieltyp

en: return edge does not point to exit in bb %d
de: Return-Kante zeigt nicht auf Ausgang in bb %d

en: return from incompatible pointer type
de: return von inkompatiblem Zeigertyp

en: return from pointer to non-enclosed address space
de: Rückgabe von Pointer auf nicht enthaltenen Adressraum

en: return makes %q#v qualified function pointer from unqualified
de: return erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: return makes integer from pointer without a cast
de: return erzeugt Ganzzahl von Zeiger ohne Typkonvertierung

en: return makes pointer from integer without a cast
de: return erzeugt Zeiger von Ganzzahl ohne Typkonvertierung

en: return not followed by barrier
de: »return« nicht gefolgt von Sperre

en: return type %q#T is incomplete
de: Rückgabetyp %q#T ist unvollständig

en: return type defaults to %<int%>
de: Rückgabetyp ist auf %<int%> voreingestellt

en: return type has Java class type %q#T
de: Rückgabetyp hat Java-Klassentyp %q#T

en: return type is an incomplete type
de: Rückgabetyp ist unvollständig

en: return type might be a candidate for a format attribute
de: Rückgabetyp könnte Kandidat für Formatattribut sein

en: return type of %qD is not %<int%>
de: Rückgabetyp von %qD ist nicht %<int%>

en: return type specification for constructor invalid
de: Angabe des Rückgabetyps für Konstruktor ist ungültig

en: return type specification for destructor invalid
de: Angabe des Rückgabetyps für Destruktor ist ungültig

en: return type specified for %<operator %T%>
de: Rückgabetyp für %<operator %T%> angegeben

en: return with value in function with no return type
de: Rückgabe eines Wertes in Funktion ohne Rückgabetyp

en: return-statement with a value, in function returning 'void'
de: Return-Anweisung mit Wert in »void« zurückgebender Funktion

en: return-statement with no value, in function returning %qT
de: Return-Anweisung ohne Wert, in %qT zurückgebender Funktion

en: returning a value from a constructor
de: Rückgabe eines Wertes von einem Konstruktor

en: returning a value from a destructor
de: Wert von Destruktor zurückgegeben

en: returning reference to temporary
de: Referenz auf temporären Wert wird zurückgegeben

en: right argument must be a slice or a string
de: rechtes Argument muss eine Scheibe oder Zeichenkette sein

en: right operand of comma operator cannot resolve address of overloaded function
de: rechter Operand des Komma-Operators kann die Adresse der überladenen Funktion nicht auflösen

en: right operand of comma operator has no effect
de: rechter Operand des Komma-Operators hat keinen Effekt

en: right operand of comma operator is a reference, not call, to function %qE
de: rechter Operand des Komma-Operators ist eine Referenz, kein Aufruf, zur Funktion %qE

en: right precision
de: rechte Präzision

en: right precision in strfmon format
de: rechte Präzision im strfmon-Format

en: right rotate count >= width of type
de: rechter Rotationszähler >= Breite des Typs

en: right rotate count is negative
de: rechter Rotationszähler ist negativ

en: right shift count >= width of type
de: Rechts-Schiebe-Weite >= Breite des Typs

en: right shift count is negative
de: Rechts-Schiebe-Weite ist negativ

en: rounding mode not supported for VAX floats
de: Rundungsmodus für VAX-Floats nicht unterstützt

en: rx200 cpu does not have FPU hardware
de: CPU RX200 hat keine FPU-Hardware

en: same canonical type node for different types %T and %T
de: gleicher kanonischer Typknoten für die unterschiedlichen Typen %T und %T

en: same_comdat_group is not a circular list
de: same_comdat_group ist keine ringförmige Liste

en: saw %d %<template<>%>, need %d for specializing a member function template
de: %d %<template<>%> gefunden, %d werden für Spezialisierung eines Elementfunktionstemplates benötigt

en: say %<typename %E%> if a type is meant
de: %<typename %E%> sagen, wenn ein Typ gemeint ist

en: scalar object %qD requires one element in initializer
de: skalares Objekt %qD erfordert ein Element in Initialisierung

en: schedule %<auto%> does not take a %<chunk_size%> parameter
de: Ablauf %<auto%> akzeptiert keinen Parameter %<chunk_size%>

en: schedule %<runtime%> does not take a %<chunk_size%> parameter
de: Ablauf %<runtime%> akzeptiert keinen Parameter %<chunk_size%>

en: schedule chunk size expression must be integral
de: Plan-Teilgrößenausdruck muss bestimmt sein

en: scope %qT before %<~%> is not a class-name
de: Bereich %qT vor %<~%> ist kein Klassenname

en: scoped enum %qT will not promote to an integral type in a future version of GCC
de: enum %qT mit Gültigkeitsbereich wird in zukünftigen GCC-Versionen nicht auf Ganzzahltyp erweitert

en: scoped enums only available with -std=c++0x or -std=gnu++0x
de: enums mit Gültigkeitsbereich nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: scoped/unscoped mismatch in enum %q#T
de: falsche Zuordnung zwischen innerhalb und außerhalb eines Gültigkeitsbereiches in enum %q#T

en: second argument of %q+D should be %<char **%>
de: zweites Argument von %q+D sollte %<char **%> sein

en: second argument to %<__builtin_prefetch%> must be a constant
de: Zweites Argument für %<__builtin_prefetch%> muss eine Konstante sein

en: second operand of conditional expression cannot resolve address of overloaded function
de: zweiter Operand des bedingten Ausdrucks kann die Adresse der überladenen Funktion nicht auflösen

en: second operand of conditional expression has no effect
de: zweiter Operand des bedingten Ausdrucks hat keinen Effekt

en: second operand of conditional expression is a reference, not call, to function %qE
de: zweiter Operand des bedingten Ausdrucks ist eine Referenz, kein Aufruf, zur Funktion %qE

en: second operand to the conditional operator is of type %<void%>, but the third operand is neither a throw-expression nor of type %<void%>
de: zweiter Operand für Bedingungsoperator ist vom Typ %<void%>, aber der dritte Operand ist weder ein Throw-Ausdruck noch vom Typ %<void%>

en: second parameter of %<va_start%> not last named argument
de: Zweiter Parameter von %<va_start%> ist nicht letztgenanntes Argument

en: section anchors must be disabled when toplevel reorder is disabled
de: Abschnittsanker müssen ausgeschaltet sein, wenn Toplevel-Neuordnung ausgeschaltet ist

en: section anchors must be disabled when unit-at-a-time is disabled
de: Abschnittsanker müssen ausgeschaltet sein, wenn »unit-at-a-time« ausgeschaltet ist

en: section attribute cannot be specified for local variables
de: Abschnitts-Attribut kann nicht für lokale Variablen angegeben werden

en: section attribute not allowed for %q+D
de: Abschnitts-Attribut nicht erlaubt für %q+D

en: section attributes are not supported for this target
de: Abschnitts-Attribute werden für dieses Ziel nicht unterstützt

en: section of %q+D cannot be overridden
de: Abschnitt von %q+D kann nicht aufgehoben werden

en: section of %q+D conflicts with previous declaration
de: Abschnitt von %q+D in Konflikt mit vorheriger Deklaration

en: selected for placement delete
de: für Platzierungs-Löschen ausgewählt

en: selector must be an immediate
de: Wähler muss »immediate« sein

en: selector must be an integer constant in the range 0..%wi
de: Selektor eine Ganzzahlkonstante im Bereich 0..%wi sein

en: setter name must terminate with %<:%>
de: Setter-Name muss mit %<:%> beendet werden

en: setting core file size limit to maximum: %m
de: Kern-Dateigrößenlimit wird gesetzt: %m

en: shadowed declaration is here
de: verdeckte Deklaration ist hier

en: shadowing built-in function %q#D
de: eingebaute Funktion %q#D wird überdeckt

en: shadowing library function %q#D
de: Bibliotheksfunktion %q#D wird überdeckt

en: shadowing previous type declaration of %q#D
de: vorherige Typdeklaration von %q#D wird überschattet

en: shared and mdll are not compatible
de: shared und mdll sind unverträglich

en: shared call_stmt:
de: Gemeinsam genutztes call_stmt:

en: shared rtx
de: Gemeinsames rtx

en: shift count not unsigned integer
de: Schiebeweite ist keine vorzeichenlose Ganzzahl

en: shift of non-integer operand
de: Schiebeoperation eines Nicht-Ganzzahloperanden

en: side effects not recomputed when ADDR_EXPR changed
de: Seiteneffekte werden bei ADDR_EXPR-Änderung nicht neu berechnet

en: signedness of type and machine mode %qs don%'t match
de: Vorzeicheneigenschaft des Typen und Maschinenmodus %qs passen nicht zusammen

en: simple IF
de: einfaches IF

en: size assigned to %qT may not be ABI-compliant and may change in a future version of GCC
de: %qT zugewiesene Größe könnte ABI-unverträglich sein und sich in zukünftigen GCC-Versionen ändern

en: size in array new must have integral type
de: Größe des Feldes bei »new« muss Ganzzahltyp haben

en: size of %q+D is %d bytes
de: Größe von %q+D ist %d Bytes

en: size of %q+D is larger than %wd bytes
de: Größe von %q+D überschreitet %wd Bytes

en: size of array %qD has non-integral type %qT
de: Feldgröße von %qD hat nicht-ganzzahligen Typen %qT

en: size of array %qD is negative
de: Größe des Feldes %qD ist negativ

en: size of array %qD is not an integral constant-expression
de: Größe des Feldes %qD ist kein konstanter Ganzzahlausdruck

en: size of array %qE has non-integer type
de: Feldgröße von %qE hat Nicht-Ganzzahltyp

en: size of array %qE is negative
de: Größe des Feldes %qE ist negativ

en: size of array %qE is too large
de: Feldgröße von %qE ist zu groß

en: size of array %qs is too large
de: Feldgröße von %qs ist zu groß

en: size of array has non-integral type %qT
de: Feldgröße hat nicht-ganzzahligen Typen %qT

en: size of array is negative
de: Größe des Feldes ist negativ

en: size of array is not an integral constant-expression
de: Größe des Feldes ist kein konstanter Ganzzahlausdruck

en: size of array is too large
de: Feldgröße ist zu groß

en: size of loop %d should be %d, not %d
de: Größe der Schleife %d sollte %d sein, nicht %d

en: size of return value of %q+D is %u bytes
de: Größe des Rückgabewertes von %q+D ist %u Bytes

en: size of return value of %q+D is larger than %wd bytes
de: Größe des Rückgabewertes von %q+D ist größer als %wd Bytes

en: size of tiles for loop blocking
de: Größe der Kacheln für Schleifenblockierung

en: size of unnamed array has non-integer type
de: Feldgröße eines unbenannten Feldes hat Nicht-Ganzzahltyp

en: size of unnamed array is negative
de: Größe des unbenannten Feldes ist negativ

en: size of unnamed array is too large
de: Größe des unbenannten Feldes ist zu groß

en: size of variable %q+D is too large
de: Größe der Variablen %q+D ist zu hoch

en: sizeof(long double) is 12
de: sizeof(long double) ist 12

en: sizeof(long double) is 16
de: sizeof(long double) ist 16

en: slice end must be integer
de: Scheibenende muss eine Ganzzahl sein

en: soft-float and long-double-128 are incompatible
de: soft-float und long-double-128 sind unverträglich

en: sorry, unimplemented:
de: nicht implementiert:

en: sorry: semantics of inline function static data %q+#D are wrong (you%'ll wind up with multiple copies)
de: Entschuldigung: Semantik der statischen Daten %q+#D der inline-Funktion ist falsch (mehrere Kopien wären die Folge)

en: source is a pointer to incomplete type
de: Quelle ist ein Zeiger auf unvollständigen Typen

en: source is not a pointer
de: Quelle ist kein Zeiger

en: source is not a pointer to class
de: Quelle ist kein Zeiger auf Klasse

en: source is not of class type
de: Quelle hat nicht Klassentypen

en: source is of incomplete class type
de: Quelle hat unvollständigen Klassentypen

en: source type is not polymorphic
de: Quellentyp ist nicht polymorph

en: spec %qs has invalid %<%%0%c%>
de: Spezifikation %qs hat ungültiges %<%%0%c%>

en: spec %qs has invalid %<%%W%c%>
de: Spezifikation %qs hat ungültiges %<%%W%c%>

en: spec %qs has invalid %<%%x%c%>
de: Spezifikation %qs hat ungültiges %<%%x%c%>

en: spec %qs invalid
de: Spezifikation %qs ist ungültig

en: spec failure: %<%%*%> has not been initialized by pattern match
de: Spezifikationsfehler: %<%%*%> wurde nicht durch Mustererkennung initialisiert

en: spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC
de: Spezifikationsfehler: mehr als ein Argument für SYSROOT_HEADERS_SUFFIX_SPEC

en: spec failure: more than one arg to SYSROOT_SUFFIX_SPEC
de: Spezifikationsfehler: mehr als ein Argument für SYSROOT_SUFFIX_SPEC

en: spec failure: unrecognized spec option %qc
de: Spezifikationsfehler: nicht erkannte Spezifikationsoption »%c«

en: spec file has no spec for linking
de: Spezifikationsdatei hat keine Spezifikation zum Binden

en: spec is '%s'
de: Spezifikation ist '%s'

en: spec-generated switch is just %<-%>
de: aus Spezifikation erzeugtes switch ist nur %<-%>

en: specialization %qT after instantiation %qT
de: Spezialisierung %qT hinter Instanziierung %qT

en: specialization of %qD after instantiation
de: Spezialisierung von %qD nach Instanziierung

en: specialization of %qD in different namespace
de: Spezialisierung von %qD in anderem Namensbereich

en: specialization of %qD must appear at namespace scope
de: Spezialisierung von %qD muss im Gültigkeitsbereich des Namensbereiches auftreten

en: specialization of %qT after instantiation
de: Spezialisierung von %qT hinter Instanziierung

en: specialization of implicitly-declared special member function
de: Spezialisierung der implizit deklarierten speziellen Elementfunktion

en: specializing %q#T in different namespace
de: %q#T wird in anderem Namensbereich spezialisiert

en: specializing member %<%T::%E%> requires %<template<>%> syntax
de: spezialisierendes Element %<%T::%E%> erfordert Syntax %<template<>%>

en: specified mode too small for enumeral values
de: angegebener Modus zu klein für Aufzählungswerte

en: specifying vector types with __attribute__ ((mode)) is deprecated
de: Angabe von Vektortypen mit __attribute__ ((Modus)) ist veraltet

en: specs %%include syntax malformed after %ld characters
de: falsche %%include-Syntax für Spezifikationen nach %ld Zeichen

en: specs %%rename syntax malformed after %ld characters
de: falsche %%rename-Syntax für Spezifikationen nach %ld Zeichen

en: specs %s spec was not found to be renamed
de: keine %s-Spezifikation zum Umbenennen gefunden

en: specs file malformed after %ld characters
de: Fehler in Spezifikationsdatei nach %ld Zeichen

en: specs unknown %% command after %ld characters
de: Spezifikation: unbekannter %%-Befehl nach %ld Zeichen

en: spurious %<>>%>, use %<>%> to terminate a template argument list
de: falsches %<>>%>; %<>%> verwenden, um eine Templateargumentliste zu beenden

en: spurious trailing %<%%%> in format
de: störendes letztes %<%%%> im Format

en: stack frame not a multiple of 8 bytes: %wd
de: Stapelrahmen ist kein Vielfaches von 8 Bytes: %wd

en: stack frame not a multiple of octabyte: %wd
de: Stapelrahmen ist kein Vielfaches eines Octabytes: %wd

en: stack frame too large
de: Stapelrahmen zu groß

en: stack guard value must be an exact power of 2
de: Stapel-Überwachungswert muss eine exakte Zweierpotenz sein

en: stack limit expression is not supported
de: Ausdruck der Stapelgrenze wird nicht unterstützt

en: stack limits not supported on this target
de: Kellergrenzen nicht für dieses Ziel unterstützt

en: stack probing requires %saccumulate-outgoing-args%s for correctness
de: Stack-Überprüfung erfordert %saccumulate-outgoing-args%s für Korrektheit

en: stack protector not protecting function: all local arrays are less than %d bytes long
de: Stack-Schutz schützt nicht Funktion: Alle lokalen Felder sind kleiner als %d Bytes

en: stack protector not protecting local variables: variable length buffer
de: Stack-Schutz schützt nicht lokale Variablen: Puffer variabler Größe

en: stack register used for global register variable
de: Stack-Register für globale Registervariable verwendet

en: stack size must be an exact power of 2
de: Stack-Größe muss eine exakte Zweierpotenz sein

en: stack size must be greater than the stack guard value
de: Stackgröße muss größer als der Stack-Überwachungswert sein

en: stack size must not be greater than 64k
de: Stackgröße darf nicht größer als 64k sein

en: stack underflow - dup* operation
de: Stapelunterlauf - dup*-Operation

en: stackframe too big: %d bytes
de: Stapelrahmen zu groß: %d Bytes

en: standard conversions are not allowed in this context
de: Standardumwandlungen sind in diesem Kontext nicht erlaubt

en: start of implied-do loop at %L could not be simplified to a constant value
de: Anfang der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden

en: statement cannot resolve address of overloaded function
de: Anweisung kann die Adresse der überladenen Funktion nicht auflösen

en: statement has VDEF but no VUSE operand
de: Anweisung hat VDEF, aber keinen VUSE-Operanden

en: statement has VDEF operand not in defs list
de: Anweisung hat VDEF-Operand, der nicht in Definitionsliste ist

en: statement has VUSE operand not in uses list
de: Anweisung hat VUSE-Operanden, der nicht in Verwendungsliste ist

en: statement has no effect
de: Anweisung hat keinen Effekt

en: statement is a reference, not call, to function %qE
de: Anweisung ist eine Referenz, kein Aufruf, zur Funktion %qE

en: statement makes a memory store, but has no VDEFS
de: Anweisung erzeugt einen Speicherzugriff, hat aber kein VDEFS

en: statement marked for throw in middle of block
de: Anweisung für throw inmitten eines Blockes markiert

en: statement marked for throw, but doesn%'t
de: Anweisung für throw markiert, tut es jedoch nicht

en: statement with no effect
de: Anweisung ohne Effekt

en: statement-expressions are not allowed outside functions nor in template-argument lists
de: Anweisungs-Ausdrücke sind weder außerhalb von Funktionen noch in Template-Argumenten erlaubt

en: static %qs cannot be declared %<mutable%>
de: statisches %qs kann nicht als %<mutable%> deklariert sein

en: static assertion failed: %E
de: statische Behauptung gescheitert: %E

en: static chain in indirect gimple call
de: statische Kette in indirektem GIMPLE-Aufruf

en: static chain with function that doesn%'t use one
de: statische Kette mit Funktion, die keine verwendet

en: static declaration of %q+D follows non-static declaration
de: Statische Deklaration von %q+D folgt nicht-statischer Deklaration

en: static is not supported on TPF-OS
de: static wird auf TPF-OS nicht unterstützt

en: static linking is not supported
de: Statische Bindung wird nicht unterstützt

en: static member %qD cannot be a bit-field
de: statisches Element %qD kann kein Bitfeld sein

en: static member %qD declared %<register%>
de: statisches Element %qD als %<register%> deklariert

en: static member function %q#D declared with type qualifiers
de: statische Elementfunktion %q#D mit Typqualifizierern deklariert

en: static member function %qD cannot have cv-qualifier
de: statische Elementfunktion %qD kann nicht CV-Qualifizierer haben

en: static or type qualifiers in non-parameter array declarator
de: »static« oder Typkennzeichner in Nicht-Parameter-Felddeklarator

en: static variable %q+D is marked dllimport
de: statische Variable %q+D ist als »dllimport« markiert

en: static_cast from type %qT to type %qT casts away qualifiers
de: static_cast des Typs %qT in Typ %qT entfernt Qualifizierer

en: statically allocated instance of Objective-C class %qE
de: statisch reservierte Instanz der Objective-C-Klasse %qE

en: stdcall and cdecl attributes are not compatible
de: Attribute stdcall und cdecl sind nicht verträglich

en: stdcall and fastcall attributes are not compatible
de: Attribute stdcall und fastcall sind nicht verträglich

en: stdcall and thiscall attributes are not compatible
de: Attribute stdcall und thiscall sind nicht verträglich

en: step of implied-do loop at %L could not be simplified to a constant value
de: Schritt der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden

en: stmt (%p) marked modified after optimization pass:
de: Anweisung (%p) nach Optimierungsdurchgang als geändert markiert:

en: storage class %<__thread%> invalid for function %qs
de: Speicherklasse %<__thread%> ungültig für Funktion %qs

en: storage class %<auto%> invalid for function %qs
de: Speicherklasse %<auto%> ungültig für Funktion %qs

en: storage class %<register%> invalid for function %qs
de: Speicherklasse %<register%> ungültig für Funktion %qs

en: storage class %qD applied to template instantiation
de: Speicherklasse %qD auf Templateinstanziierung angewendet

en: storage class specified for %qs
de: Speicherklasse %qs angegeben

en: storage class specified for parameter %qE
de: Speicherklasse für Parameter %qE angegeben

en: storage class specified for parameter %qs
de: Speicherklasse für Parameter %qs angegeben

en: storage class specified for structure field
de: Speicherklasse für Strukturfeld angegeben

en: storage class specified for structure field %qE
de: Speicherklasse für Strukturfeld %qE angegeben

en: storage class specified for template parameter %qs
de: Speicherklasse für Template-Parameter %qs angegeben

en: storage class specified for typename
de: Speicherklasse für Typnamen angegeben

en: storage class specified for unnamed parameter
de: Speicherklasse für unbenannten Parameter angegeben

en: storage class specifiers invalid in friend function declarations
de: Speicherklassenangaben sind in friend-Funktionsdeklarationen ungültig

en: storage class specifiers invalid in parameter declarations
de: Speicherklassenangaben sind in Parameterdeklarationen ungültig

en: storage size of %q+D isn%'t constant
de: Speichergröße von %q+D ist nicht konstant

en: storage size of %q+D isn%'t known
de: Speichergröße von %q+D ist unbekannt

en: storage size of %qD isn%'t constant
de: Speichergröße von %qD ist nicht konstant

en: storage size of %qD isn%'t known
de: Speichergröße von %qD ist unbekannt

en: stray %<@%> in program
de: verirrtes %<@%> im Programm

en: stray %<\%o%> in program
de: verirrtes %<\%o%> im Programm

en: stray %qc in program
de: verirrtes %qc im Programm

en: stray %qs between Objective-C++ methods
de: überflüssiges %qs zwischen Objective-C++ Methoden

en: stray %qs in program
de: verirrtes %qs im Programm

en: strftime formats cannot format arguments
de: strftime-Formate können keine Argumente formatieren

en: string length %qd is greater than the length %qd ISO C%d compilers are required to support
de: Zeichenkettenlänge %qd ist größer als die Länge %qd, die von ISO-C%d-Compilern unterstützt werden muss

en: string literal in function template signature
de: Zeichenkettenliteral in Signatur des Funktionstemplate

en: strong using only meaningful at namespace scope
de: starkes »using« ist nur im Gültigkeitsbereich des Namensbereiches sinnvoll

en: strong-cast assignment has been intercepted
de: Zuweisung mit starker Typumwandlung wurde abgefangen

en: strong-cast may possibly be needed
de: Möglicherweise wird starke Typumwandlung benötigt

en: struct defined here
de: »struct« wurde hier definiert

en: struct has no members
de: struct hat keine Elemente

en: struct has no named members
de: struct hat keine benannten Elemente

en: structure alignment must be a small power of two, not %d
de: Strukturausrichtung muss eine kleine Zweierpotenz sein, nicht %d

en: structure size boundary can only be set to %s
de: Grenze für Strukturgröße kann nur auf %s gesetzt werden

en: subframework include %s conflicts with framework include
de: Unter-Framework-Include %s steht mit Framework-Include in Konflikt

en: subscript missing in array reference
de: Index fehlt in Feldreferenz

en: subscripted value is neither array nor pointer
de: indizierter Wert ist weder ein Feld noch ein Zeiger

en: subscripted value is neither array nor pointer nor vector
de: indizierter Wert ist weder Feld noch Zeiger noch Vektor

en: subscripted value is pointer to function
de: indizierter Wert ist Zeiger auf Funktion

en: subscripting array declared %<register%>
de: Indizierung eines als %<register%> deklarierten Feldes

en: suggest braces around empty body in %<do%> statement
de: geschweifte Klammern um leeren Körper in %<do%>-Anweisung empfohlen

en: suggest braces around empty body in an %<else%> statement
de: geschweifte Klammern um leeren Körper in einer %<else%>-Anweisung empfohlen

en: suggest braces around empty body in an %<if%> statement
de: geschweifte Klammern um leeren Körper in einer %<if%>-Anweisung empfohlen

en: suggest explicit braces around empty body in %<do%> statement
de: es wird empfohlen, explizite geschweifte Klammern um leeren Körper in %<do%>-Anweisung zu setzen

en: suggest explicit braces to avoid ambiguous %<else%>
de: es wird empfohlen, explizite geschweifte Klammern zu setzen, um mehrdeutiges %<else%> zu vermeiden

en: suggest parentheses around %<&&%> within %<||%>
de: Klammern um %<&&%> innerhalb von %<||%> empfohlen

en: suggest parentheses around %<+%> in operand of %<&%>
de: Klammern um %<+%> in Operand von %<&%> empfohlen

en: suggest parentheses around %<+%> inside %<<<%>
de: Klammern um %<+%> innerhalb von %<<<%> empfohlen

en: suggest parentheses around %<+%> inside %<>>%>
de: Klammern um %<+%> innerhalb von %<>>%> empfohlen

en: suggest parentheses around %<-%> in operand of %<&%>
de: Klammern um %<-%> in Operand von %<&%> empfohlen

en: suggest parentheses around %<-%> inside %<<<%>
de: Klammern um %<-%> innerhalb von %<<<%>

en: suggest parentheses around %<-%> inside %<>>%>
de: Klammern um %<-%> innerhalb von %<>>%> empfohlen

en: suggest parentheses around %<>>%> expression
de: Klammern um %<>>%>-Ausdruck empfohlen

en: suggest parentheses around arithmetic in operand of %<^%>
de: Klammern um Arithmetik in Operand von %<^%> empfohlen

en: suggest parentheses around arithmetic in operand of %<|%>
de: Klammern um Arithmetik in Operand von %<|%> empfohlen

en: suggest parentheses around assignment used as truth value
de: Um Zuweisung, die als Wahrheitswert verwendet wird, werden Klammern empfohlen

en: suggest parentheses around comparison in operand of %<!=%>
de: Klammern um Vergleich in Operand von %<!=%> empfohlen

en: suggest parentheses around comparison in operand of %<&%>
de: Klammern um Vergleich in Operand von %<&%> empfohlen

en: suggest parentheses around comparison in operand of %<==%>
de: Klammern um Vergleich in Operand von %<==%> empfohlen

en: suggest parentheses around comparison in operand of %<^%>
de: Klammern um Vergleich in Operand von %<^%> empfohlen

en: suggest parentheses around comparison in operand of %<|%>
de: Klammern um Vergleich in Operand von %<|%> empfohlen

en: suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>
de: Klammern um Operand von %<!%> empfohlen, oder Änderung von %<&%> in %<&&%> oder %<!%> in %<~%>

en: suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>
de: Klammern um Operand von %<!%> empfohlen, oder Änderung von %<|%> in %<||%> oder %<!%> in %<~%>

en: suggested alternative: | suggested alternatives:
de[0]: empfohlene Alternative:
de[1]: empfohlene Alternativen:

en: support for mode %qs
de: Unterstützung für Modus %qs

en: switch %qs does not start with %<-%>
de: Schalter %qs beginnt nicht mit %<-%>

en: switch %qs is no longer supported
de: Schalter %qs wird nicht mehr unterstützt

en: switch -mcpu=%s conflicts with -march=%s switch
de: Schalter -mcpu=%s steht mit dem Schalter -march=%s in Konflikt

en: switch jumps into statement expression
de: switch springt in Anweisungs-Ausdruck

en: switch jumps over variable initialization
de: switch springt über Variableninitialisierung

en: switch missing default case
de: Die Standardfallbehandlung in switch fehlt

en: switch quantity not an integer
de: switch-Größe ist keine Ganzzahl

en: switch starts here
de: switch beginnt hier

en: switch statement of size %lu entries too large
de: switch-Anweisung der Größe %lu Einträge zu groß

en: symbol used as immediate operand
de: Zeichen als Immediate-Operand verwendet

en: symbol used with both base and indexed registers
de: Zeichen sowohl mit Basis- als auch Index-Registern verwendet

en: symbol with offset used in PIC mode
de: Symbol mit Offset im PIC-Modus verwendet

en: symbolic memory references are only supported on z10 or later
de: symbolische Speicherreferenzen werden nur auf z10 oder neuer unterstützt

en: synthesized method %qD first required here
de: erzeugte Methode %qD zuerst hier erfordert

en: sysctl for kern.osversion failed: %m
de: sysctl für kern.osversion gescheitert: %m

en: system path %qs is not absolute
de: System-Pfad %qs ist nicht absolut

en: taking address of constructor %qE
de: Adresse des Konstruktors %qE wird genommen

en: taking address of destructor %qE
de: Adresse des Destruktors %qE wird genommen

en: taking address of expression of type %<void%>
de: Adresse des Ausdrucks des Typs %<void%> wird genommen

en: taking address of temporary
de: Adresse eines temporären Wertes wird ermittelt

en: taking address of xvalue (rvalue reference)
de: Adresse eines X-Wertes (R-Wert-Referenz) wird genommen

en: taking the address of a label is non-standard
de: Das Ermitteln der Adresse einer Marke ist nicht standardkonform

en: target CPU does not support ARM mode
de: Ziel-CPU unterstützt nicht ARM-Modus

en: target CPU does not support THUMB instructions
de: Ziel-CPU unterstützt keine THUMB-Befehle

en: target CPU does not support interworking
de: Ziel-CPU unterstützt keine Zusammenarbeit

en: target attribute is not supported on this machine
de: Ziel-Attribut wird auf dieser Maschine nicht unterstützt

en: target attribute or pragma changes AltiVec ABI
de: Ziel-Attribut oder Pragma ändert AltiVec ABI

en: target attribute or pragma changes SPE ABI
de: Ziel-Attribut oder Pragma ändert SPE ABI

en: target attribute or pragma changes darwin64 ABI
de: Ziel-Attribut oder Pragma ändert darwin64 ABI

en: target attribute or pragma changes double precision floating point
de: Ziel-Attribut oder Pragma ändert Gleitkomma mit doppelter Genauigkeit

en: target attribute or pragma changes long double size
de: Ziel-Attribut oder Pragma ändert Größe von long double

en: target attribute or pragma changes single precision floating point
de: Ziel-Attribut oder Pragma ändert Gleitkomma mit einfacher Genauigkeit

en: target format does not support infinity
de: Zielformat unterstützt nicht »unendlich«

en: target is not pointer or reference
de: Ziel ist kein Zeiger oder Referenz

en: target is not pointer or reference to class
de: Ziel ist kein Zeiger oder Referenz auf Klasse

en: target is not pointer or reference to complete type
de: Ziel ist kein Zeiger oder Referenz auf vollständigen Typen

en: target of conversion might be a candidate for a format attribute
de: Ziel der Umwandlung könnte Kandidat ein für ein Formatattribut sein

en: target of initialization might be a candidate for a format attribute
de: Ziel der Initialisierung könnte ein Kandidat für Formatattribut sein

en: target specific builtin not available
de: zielspezifische eingebaute Funktion ist nicht verfügbar

en: target specific option mismatch
de: Fehlzuordnung zielspezifischer Optionen

en: target system does not support debug output
de: Zielsystem unterstützt keine Testausgaben

en: target system does not support the "%s" debug format
de: Zielsystem unterstützt nicht das Testformat "%s"

en: template argument %d is invalid
de: Templateargument %d ist ungültig

en: template argument %qE involves template parameter(s)
de: Templateargument %qE betrifft Templateparameter

en: template argument for %qD uses local type %qT
de: Templateargument für %qD verwendet lokalen Typ %qT

en: template argument required for %<%s %T%>
de: Template-Argument für %<%s %T%> benötigt

en: template arguments to %qD do not match original template %qD
de: Template-Argumente für %qD passen nicht zum ursprünglichen Template %qD

en: template class without a name
de: Templateklasse ohne Namen

en: template declaration of %<typedef%>
de: Templatedeklaration von %<typedef%>

en: template declaration of %q#D
de: Templatedeklaration von %q#D

en: template definition of non-template %q#D
de: Template-Definition eines Nicht-Templates %q#D

en: template header not allowed in member definition of explicitly specialized class
de: Template-Header in Elementdefinition einer explizit spezialisierten Klasse nicht erlaubt

en: template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) instantiating %qD
de: Instanziierungstiefe für Templates überschreitet Höchstwert %d (-ftemplate-depth= verwenden, um dies zu erhöhen) bei Instanziierung von %qD

en: template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)
de: Instanziierungstiefe für Templates überschreitet Höchstwert %d (-ftemplate-depth= verwenden, um dies zu erhöhen) bei Instanziierung von %q+D, möglicherweise von Erzeugung der virtuellen Tabelle

en: template parameter %q+#D
de: Template-Parameter %q+#D

en: template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type
de: Templateparameter %qD vom Typ %qT ist in ganzzahligem Konstantenausdruck nicht erlaubt, da er nicht Ganzzahl- oder Aufzählungstyp hat

en: template parameter list used in explicit instantiation
de: Templateparameterliste in expliziter Instanziierung verwendet

en: template parameter lists provided don%'t match the template parameters of %qD
de: angegebene Template-Parameterlisten passen nicht zu Templateparametern von %qD

en: template parameter pack %qD cannot have a default argument
de: Templateparameterpack %qD kann kein Standardargument haben

en: template parameter pack cannot have a default argument
de: Templateparameterpack kann kein Standardargument haben

en: template parameter packs cannot have default arguments
de: Template-Parameterpacks können keine Standardargumente haben

en: template parameter type %qT declared %<friend%>
de: Template-Parameter-Typ %qT als %<friend%> deklariert

en: template parameters cannot be friends
de: Template-Parameter können keine »friends« sein

en: template parameters do not match template
de: Template-Parameter passen nicht zum Template

en: template parameters not used in partial specialization:
de: nicht in partieller Spezialisierung verwendete Templateparameter:

en: template specialization of %qD not allowed by ISO C++
de: Templatespezialisierung von %qD durch ISO C++ nicht erlaubt

en: template specialization with C linkage
de: Templatespezialisierung mit C-Bindung angegeben

en: template specifiers not specified in declaration of %qD
de: keine Templatespezifizierer in Deklaration von %qD angegeben

en: template type parameters must use the keyword %<class%> or %<typename%>
de: Templatetypparameter müssen das Schlüsselwort %<class%> oder %<typename%> verwenden

en: template with C linkage
de: Template mit C-Bindung

en: template-id %qD for %q+D does not match any template declaration
de: Template-ID %qD für %q+D passt zu keiner Templatedeklaration

en: template-id %qD in declaration of primary template
de: Template-ID %qD in Deklaration des ersten Templates

en: template-id %qD used as a declarator
de: Template-ID %qD als Deklarator verwendet

en: template-parameter-
de: Template-Parameter-

en: templates may not be %<virtual%>
de: Templates dürfen nicht %<virtual%> sein

en: that particular -g option is invalid with -maout and -melinux
de: diese spezielle Option -g ist mit -maout und -melinux ungültig

en: the %<getter%> attribute may only be specified once
de: das %<getter%>-Attribut darf nur einmal angegeben werden

en: the %<interrupt%> attribute requires %<-msoft-float%>
de: das %<interrupt%>-Attribut erfordert %<-msoft-float%>

en: the %<interrupt%> attribute requires a MIPS32r2 processor
de: das %<interrupt%>-Attribut erfordert einen MIPS32r2-Prozessor

en: the %<setter%> attribute may only be specified once
de: das %<setter%>-Attribut darf nur einmal angegeben werden

en: the %qs architecture does not support branch-likely instructions
de: die Architektur %qs unterstützt keine Befehle mit Sprungwahrscheinlichkeit

en: the %qs architecture does not support paired-single instructions
de: die Architektur %qs unterstützt keine paarweisen Einzel-Befehle

en: the %qs architecture does not support the synci instruction
de: die Architektur %qs unterstützt nicht den synci-Befehl

en: the ' ' printf flag
de: das » «-printf-Kennzeichen

en: the '!' strfmon flag
de: das »!«-strfmon-Kennzeichen

en: the '#' printf flag
de: das »#«-printf-Kennzeichen

en: the '#' strftime flag
de: das »#«-strftime-Kennzeichen

en: the '%s' and '%s' arguments of '%s' intrinsic at %L must be of the same kind %d/%d
de: Argumente »%s« und »%s« des intrinsischen »%s« bei %L müssen von der selben Art %d/%d sein

en: the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d
de: Argumente »%s« und »%s« des intrinsischen »%s« bei %L müssen den selben Rang %d/%d haben

en: the ''' printf flag
de: das »'«-printf-Kennzeichen

en: the ''' scanf flag
de: das »'«-scanf-Kennzeichen

en: the '(' strfmon flag
de: das »(«-strfmon-Kennzeichen

en: the '+' printf flag
de: das »+«-printf-Kennzeichen

en: the '+' strfmon flag
de: das »+«-strfmon-Kennzeichen

en: the '-' printf flag
de: das »-«-printf-Kennzeichen

en: the '-' strfmon flag
de: das »-«-strfmon-Kennzeichen

en: the '-' strftime flag
de: das »-«-strftime-Kennzeichen

en: the '0' printf flag
de: das »0«-printf-Kennzeichen

en: the '0' strftime flag
de: das »0«-strftime-Kennzeichen

en: the 'E' strftime modifier
de: der »E«-strftime-Modifizierer

en: the 'I' printf flag
de: das »I«-printf-Kennzeichen

en: the 'I' scanf flag
de: das »I«-scanf-Kennzeichen

en: the 'O' modifier
de: der »O«-Modifizierer

en: the 'O' strftime modifier
de: der »O«-strftime-Modifizierer

en: the '^' strfmon flag
de: das »^«-strfmon-Kennzeichen

en: the '^' strftime flag
de: das »^«-strftime-Kennzeichen

en: the '_' strftime flag
de: das »_«-strftime-Kennzeichen

en: the 'a' scanf flag
de: das »a«-scanf-Kennzeichen

en: the 'm' scanf flag
de: das »m«-scanf-Kennzeichen

en: the 'q' diagnostic flag
de: das »q«-Diagnose-Kennzeichen

en: the -shared option is not currently supported for VAX ELF
de: Die Option -shared wird derzeit nicht für VAX ELF unterstützt

en: the ABI of passing struct with a flexible array member has changed in GCC 4.4
de: Das ABI der Struct-Übergabe mit einem flexiblen Feldelement hat sich in GCC 4.4 geändert

en: the ABI of passing structure with complex float member has changed in GCC 4.4
de: Das ABI der Strukturübergabe mit komplexem Gleitkommaelement hat sich in GCC 4.4 geändert

en: the ABI of passing union with long double has changed in GCC 4.4
de: Das ABI der Union-Übergabe mit »long double« hat sich in GCC 4.4 geändert

en: the RX200 cpu does not have FPU hardware
de: Die RX200-CPU hat keine FPU-Hardware

en: the address of %qD will always evaluate as %<true%>
de: Die Adresse von %qD wird immer zu %<wahr%> auswerten

en: the address of %qD will never be NULL
de: Die Adresse von %qD wird nie NULL sein

en: the address of a label cannot appear in a constant-expression
de: die Adresse einer Marke kann nicht in einem Konstanten-Ausdruck auftreten

en: the assignment suppression scanf feature
de: das scanf-Merkmal der Zuweisungsunterdrückung

en: the default argument for parameter %d of %qD has not yet been parsed
de: das Standardargument für den Parameter %d von %qD wurde noch nicht gelesen

en: the dot syntax is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine Dot-Syntax

en: the fifth argument must be an 8-bit immediate
de: fünftes Argument muss ein 8-Bit-Immediate sein

en: the file is not in OpenScop format
de: die Datei ist nicht im OpenScop-Format

en: the first parameter of %<operator new%> cannot have a default argument
de: der erste Parameter von %<operator_new%> kann nicht das Standardargument haben

en: the frame size of %wd bytes is larger than %wd bytes
de: die Rahmengröße von %wd Bytes überschreitet %wd Bytes

en: the graphite file read for scop %d does not contain a legal transform
de: für Scop %d gelesene Graphite-Datei enthält keine gültige Umwandlung

en: the language is not recognized
de: die Sprache wurde nicht erkannt

en: the last argument must be a 1-bit immediate
de: Das letzte Argument muss ein 1-Bit-Immediate sein

en: the last argument must be a 2-bit immediate
de: Das letzte Argument muss ein 2-Bit-Immediate sein

en: the last argument must be a 32-bit immediate
de: Das letzte Argument muss ein 32-Bit-Immediate sein

en: the last argument must be a 4-bit immediate
de: Das letzte Argument muss ein 4-Bit-Immediate sein

en: the last argument must be a 5-bit immediate
de: Das letzte Argument muss ein 5-Bit-Immediate sein

en: the last argument must be an 8-bit immediate
de: Das letzte Argument muss ein 8-Bit-Immediate sein

en: the m210 does not have little endian support
de: der m210 hat keine Little-Endian-Unterstützung

en: the mangled name of %qD will change in a future version of GCC
de: der verarbeitete Name von %qD« wird sich in einer zukünftigen Version des GCC ändern

en: the next to last argument must be an 8-bit immediate
de: Das vorletzte Argument muss ein 8-Bit-Immediate sein

en: the offset of %qD may not be ABI-compliant and may change in a future version of GCC
de: der Versatz von %qD könnte ABI-unverträglich sein und sich in einer zukünftigen GCC-Version ändern

en: the omitted middle operand in ?: will always be %<true%>, suggest explicit middle operand
de: Der ausgelassene mittlere Operand in ?: wird immer %<wahr%> sein; ausdrücklicher mittlerer Operand wird empfohlen

en: the result of the conversion is unspecified because %qE is outside the range of type %qT
de: das Ergebnis der Umwandlung ist nicht spezifiziert, da %qE außerhalb des Wertebereichs des Typs %qT liegt

en: the size of array %qE can%'t be evaluated
de: die Größe des Feldes %qE kann nicht ausgewertet werden

en: the size of array can %'t be evaluated
de: die Größe eines Feldes kann nicht ausgewertet werden

en: the third argument must be an 8-bit immediate
de: drittes Argument muss ein 8-Bit-Immediate sein

en: the type %qT of constexpr variable %qD is not literal
de: der Typ %qT der Variable %qD als konstanter Ausdruck ist kein Literal

en: the type being destroyed is %qT, but the destructor refers to %qT
de: der zerstörte Typ ist %qT, aber der Destruktor verweist auf %qT

en: the type of '%s' at %C has not been declared within the interface
de: der Typ von »%s« bei %C wurde nicht innerhalb der Schnittstelle deklariert

en: the use of _OBJC_-prefixed variable names to select meta-data sections is deprecated at 4.6 and will be removed in 4.7
de: die Verwendung von Variablennamen mit Prefix _OBJC_ zur Metadatenauswahl ist bei 4.6 veraltet und wird in 4.7 entfernt

en: the value of %qD is not usable in a constant expression
de: der Wert von %qD ist in konstantem Ausdruck nicht verwendbar

en: there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available
de: es gibt keine Argumente für %qD, die von einem Templateparameter abhängen, weshalb eine Deklaration von %qD verfügbar sein muss

en: third argument of %q+D should probably be %<char **%>
de: drittes Argument von %q+D sollte wahrscheinlich %<char **%> sein

en: third argument to %<__builtin_prefetch%> must be a constant
de: Drittes Argument für %<__builtin_prefetch%> muss eine Konstante sein

en: third operand of conditional expression cannot resolve address of overloaded function
de: dritter Operand des bedingten Ausdrucks kann die Adresse der überladenen Funktion nicht auflösen

en: third operand of conditional expression has no effect
de: dritter Operand des bedingten Ausdrucks hat keinen Effekt

en: third operand of conditional expression is a reference, not call, to function %qE
de: dritter Operand des bedingten Ausdrucks ist eine Referenz, kein Aufruf, zur Funktion %qE

en: third operand to the conditional operator is of type %<void%>, but the second operand is neither a throw-expression nor of type %<void%>
de: dritter Operand für Bedingungsoperator ist vom Typ %<void%>, aber der zweite Operand ist weder ein Throw-Ausdruck noch vom Typ %<void%>

en: this builtin function is only available on the fr405 and fr450
de: diese eingebaute Funktion ist nur auf dem fr405 und fr450 verfügbar

en: this builtin function is only available on the fr450
de: diese eingebaute Funktion ist nur auf dem fr450 verfügbar

en: this builtin function is only available on the fr500 and fr550
de: diese eingebaute Funktion ist nur auf dem fr500 und fr550 verfügbar

en: this can result in poorly optimized code
de: dies kann zu schlecht optimiertem Code führen

en: this decimal constant is unsigned only in ISO C90
de: diese Dezimalkonstante ist nur in ISO-C90 vorzeichenlos

en: this decimal constant would be unsigned in ISO C90
de: diese Dezimalkonstante wäre in ISO-C90 vorzeichenlos

en: this is the first default label
de: Dies ist die erste Standardmarke

en: this is the first entry overlapping that value
de: Dies ist der erste Eintrag, der diesen Wert überschneidet

en: this is the insn:
de: dies ist der Befehl:

en: this media function is only available on the fr400 and fr550
de: diese Medienfunktion ist nur auf dem fr400 und fr550 verfügbar

en: this media function is only available on the fr500
de: diese Medienfunktion ist nur auf dem fr500 verfügbar

en: this target does not support %qs
de: dieses Ziel unterstützt nicht %qs

en: this target machine does not have delayed branches
de: diese Zielmaschine hat keine verzögerten Zweige

en: thread-local COMMON data not implemented
de: Thread-lokale COMMON-Daten nicht implementiert

en: thread-local declaration of %q#D follows non-thread-local declaration
de: Thread-lokale Deklaration von %q#D folgt nicht-Thread-lokaler Deklaration

en: thread-local declaration of %q+D follows non-thread-local declaration
de: Thread-lokale Deklaration von %q+D folgt nicht-Thread-lokaler Deklaration

en: threadprivate variable %qE used in untied task
de: threadprivate Variable %qE in unverknüpfter Task verwendet

en: throwing NULL, which has integral, not pointer type
de: wirft NULL, was ganzzahlig, aber kein Zeigertyp ist

en: tls_model argument must be one of "local-exec", "initial-exec", "local-dynamic" or "global-dynamic"
de: Argument für tls_model muss »local-exec«, »initial-exec«, »local-dynamic« oder »global-dynamic« sein

en: tls_model argument not a string
de: Argument für tls_model ist keine Zeichenkette

en: to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified
de: zur Sicherheit müssen alle vorübergehenden Zeiger in Umwandlung von %qT in %qT mit %<const%> qualifiziert sein

en: to describe a pointer to a VLIW function, use syntax like this:
de: um Zeiger auf VLIW-Funktion zu beschreiben, folgende Syntax verwenden:

en: to describe an array of VLIW function pointers, use syntax like this:
de: um Feld von VLIW-Funktionszeigern zu beschreiben, folgende Syntax verwenden:

en: to generate dependencies you must specify either -M or -MM
de: um Abhängigkeiten zu erzeugen, müssen Sie entweder -M oder -MM angeben

en: to refer to a type member of a template parameter, use %<typename %E%>
de: um auf ein Typelement eines Templateparameters zu verweisen, %<typename %E%> verwenden

en: too few arguments to %%:compare-debug-auxbase-opt
de: zu wenige Argumente für %%:compare-debug-auxbase-opt

en: too few arguments to %%:version-compare
de: zu wenige Argumente für %%:version-compare

en: too few arguments to %qE
de: zu wenige Argumente für %qE

en: too few arguments to constructor %q#D
de: zu wenige Argumente für Konstruktor %q#D

en: too few arguments to function
de: zu wenige Argumente für Funktion

en: too few arguments to function %<va_start%>
de: Zu wenige Argumente für %<va_start%>

en: too few arguments to function %q#D
de: zu wenige Argumente für Funktion %q#D

en: too few arguments to function %qE
de: Zu wenige Argumente für Funktion %qE

en: too few arguments to member function %q#D
de: Zu wenige Argumente für Elementfunktion %q#D

en: too few arguments to method %q#D
de: zu wenige Argumente für Methode %q#D

en: too few expressions for struct
de: zu wenig Ausdrücke für Struktur

en: too few template parameter lists in declaration of %qD
de: zu wenige Templateparameterlisten in Deklaration von %qD

en: too few template-parameter-lists
de: zu wenige Templateparameterlisten

en: too large function value type, needs %d registers, have only %d registers for this
de: zu großer Funktionswerttyp, benötigt %d Register, aber nur %d stehen zur Verfügung

en: too late for # directive to set debug directory
de: zu spät für »#«-Direktive, um Debug-Verzeichnis festzulegen

en: too many #pragma options align=reset
de: zu viele #pragma options align=reset

en: too many %qs clauses
de: zu viele %qs-Klauseln

en: too many ALU instructions emitted (%d)
de: zu viele ALU-Befehle ausgegeben (%d)

en: too many alternatives in %<asm%>
de: zu viele Alternativen in %<asm%>

en: too many arguments
de: zu viele Argumente

en: too many arguments for format
de: zu viele Argumente für Format

en: too many arguments to %%:compare-debug-auxbase-opt
de: zu viele Argumente für %%:compare-debug-auxbase-opt

en: too many arguments to %%:compare-debug-dump-opt
de: zu viele Argumente für %%:version-compare

en: too many arguments to %%:compare-debug-self-opt
de: zu viele Argumente für %%:compare-debug-self-opt

en: too many arguments to %%:version-compare
de: zu viele Argumente für %%:version-compare

en: too many arguments to %qE
de: zu viele Argumente für %qE

en: too many arguments to constructor %q#D
de: zu viele Argumente für Konstruktor %q#D

en: too many arguments to function
de: zu viele Argumente für Funktion

en: too many arguments to function %q#D
de: zu viele Argumente für Funktion %q#D

en: too many arguments to function %qE
de: zu viele Argumente für Funktion %qE

en: too many arguments to member function %q#D
de: zu viele Argumente für Elementfunktion %q#D

en: too many arguments to method %q#D
de: zu viele Argumente für Methode %q#D

en: too many arguments to method %qE
de: zu viele Argumente für Methode %qE

en: too many arguments to overloaded function %s
de: Zu viele Argumente für überladene Funktion %s

en: too many braces around initializer for %qT
de: zu viele geschweifte Klammern um Initialisierung für %qT

en: too many eh edges %i
de: zu viele eh-Kanten %i

en: too many elements in composite literal
de: zu viele Elemente in zusammengesetztem Literal

en: too many expressions for struct
de: zu viele Ausdrücke für Struktur

en: too many filenames given.  Type %s --help for usage
de: zu viele Dateinamen angegeben. Für Hilfe »%s --help« eingeben

en: too many initializers for %qT
de: zu viele Initialisierer für %qT

en: too many input files
de: zu viele Eingabedateien

en: too many loop exits recorded
de: Zu viele Schleifenausgänge aufgezeichnet

en: too many outgoing branch edges from bb %i
de: zu viele abgehende Zweig-Kanten vom bb %i

en: too many template parameter lists in declaration of %qD
de: zu viele Templateparameterlisten in Deklaration von %qD

en: too many template-parameter-lists
de: zu viele Templateparameterlisten

en: too many values in return statement
de: zu viele Werte in Rückgabeanweisung

en: too many variables for range clause with channel
de: zu viele Variablen in Bereichsklausel mit Kanal

en: too much stack space to dispose of: %d
de: Zu viel Stapelspeicher zu entsorgen: %d

en: too much stack space to prepare: %d
de: Zu viel Stapelspeicher vorzubereiten: %d

en: top-level declaration of %qs specifies %<auto%>
de: Deklaration höchster Ebene von %qs gibt %<auto%> an

en: toplevel reorder must be disabled when unit-at-a-time is disabled
de: Toplevel-Neuordnung muss ausgeschaltet sein, wenn »unit-at-a-time« ausgeschaltet ist

en: total size of local objects too large
de: Gesamtgröße der lokalen Objekte zu hoch

en: total size of local variables exceeds architecture limit
de: Gesamtgröße der lokalen Variablen übersteigt Grenze der Architektur

en: traditional C lacks a separate namespace for labels, identifier %qE conflicts
de: traditionelles C bietet keinen separaten Namensraum für Marken an, Bezeichner %qE steht in Konflikt

en: traditional C rejects ISO C style function definitions
de: traditionelles C weist Funktionsdefinitionen im ISO-C-Stil zurück

en: traditional C rejects automatic aggregate initialization
de: traditionelles C lehnt automatische Gesamt-Initialisierung ab

en: traditional C rejects initialization of unions
de: traditionelles C lehnt Initialisierung von unions ab

en: traditional C rejects string constant concatenation
de: traditionelles C weist Zeichenkettenkonstantenverkettung zurück

en: traditional C rejects the unary plus operator
de: traditionelles C weist den unären Plus-Operator zurück

en: trampoline generated for nested function %qD
de: Trampolin für geschachtelte Funktion %qD erzeugt

en: transformational intrinsic '%s' at %L is not permitted in an initialization expression
de: Variable »%s« bei %L kann nicht in einem Initialisierungs-Ausdruck auftreten

en: trap mode not supported for VAX floats
de: Trap-Modus für VAX-Floats nicht unterstützt

en: trap mode not supported on Unicos/Mk
de: Trap-Modus für Unicos/Mk nicht unterstützt

en: tree check: %s, have %s in %s, at %s:%d
de: Baumprüfung: %s, haben %s in %s, bei %s:%d

en: tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d
de: Baumprüfung: auf Elt %d von tree_vec mit %d Elts in %s bei %s:%d zugegriffen

en: tree check: accessed operand %d of %s with %d operands in %s, at %s:%d
de: Baumprüfung: auf Operand %d von %s mit %d Operanden in %s bei %s:%d zugegriffen

en: tree check: accessed operand %d of omp_clause %s with %d operands in %s, at %s:%d
de: Baumprüfung: auf Operand %d von omp_clause %s mit %d Operanden in %s bei %s:%d zugegriffen

en: tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d
de: Baumprüfung: Klasse %qs nicht erwartet, haben %qs (%s) in %s, bei %s:%d

en: tree check: expected class %qs, have %qs (%s) in %s, at %s:%d
de: Baumprüfung: Klasse %qs erwartet, haben %qs (%s) in %s, bei %s:%d

en: tree check: expected none of %s, have %s in %s, at %s:%d
de: Baumprüfung: nichts von %s erwartet, haben %s in %s, bei %s:%d

en: tree check: expected omp_clause %s, have %s in %s, at %s:%d
de: Baumprüfung: omp_clause %s erwartet, haben %s in %s, bei %s:%d

en: tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d
de: Baumprüfung: Baum mit enthaltener Struktur %qs erwartet, haben %qs in %s, bei %s:%d

en: tree code %qs is not supported in gimple streams
de: Baumcode %qs wird in GIMPLE-Strömen nicht unterstützt

en: tree list ends on depth %i
de: Baumliste endet bei Tiefe %i

en: true/false edge after a non-GIMPLE_COND in bb %d
de: Wahr/Falsch-Kante hinter einer Nicht-GIMPLE_COND in bb %d

en: try reducing the number of local variables
de: versuchen Sie, die Anzahl der lokalen Variablen zu verringern

en: try removing the parentheses around the type-id
de: Klammern um die Type-ID sollten entfernt werden

en: try using %qE instead
de: stattdessen %qE verwenden

en: trying to encode non-integer type as a bitfield
de: es wird versucht, einen Nicht-Ganzzahltyp als Bitfeld zu kodieren

en: trying to finish struct, but kicked out due to previous parse errors
de: Lesen der struct konnte wegen Syntaxfehlern nicht beendet werden

en: trying to make class %qT a friend of global scope
de: Versuch, die Klasse %qT zu einem »friend« des globalen Gültigkeitsbereiches zu machen

en: two or more data types in declaration of %qs
de: zwei oder mehr Datentypen in Deklaration von %qs

en: two or more data types in declaration specifiers
de: zwei oder mehr Datentypen in Deklaration

en: type %q#T argument given to %<delete%>, expected pointer
de: Argument vom Typ %q#T wurde an %<delete%> übergeben, Zeiger erwartet

en: type %qE has a user-defined constructor
de: Typ %qE hat einen benutzerdefinierten Konstruktor

en: type %qE has a user-defined destructor
de: Typ %qE hat einen benutzerdefinierten Destruktor

en: type %qE has no default constructor to call
de: Typ %qE hat keinen aufrufbaren Standard-Konstruktor

en: type %qE has virtual member functions
de: Typ %qE hat virtuelle Elementfunktionen

en: type %qT does not have a known size
de: Typ %qT hat keine bekannte Größe

en: type %qT for explicit instantiation %qD does not match declared type %qT
de: Typ %qT für explizite Instanziierung %qD passt nicht zum deklarierten Typ %qT

en: type %qT is disallowed in Java %<throw%> or %<catch%>
de: Typ %qT ist in Javas %<throw%> oder %<catch%> nicht erlaubt

en: type %qT is not a base type for type %qT
de: Typ %qT ist kein Basistyp für Typ %qT

en: type %qT is not a direct base of %qT
de: Typ %qT ist keine direkte Basis von %qT

en: type %qT is not a direct or virtual base of %qT
de: Typ %qT ist keine direkte oder virtuelle Basis von %qT

en: type %qT is not derived from %<java::lang::Throwable%>
de: Typ %qT ist nicht von %<java::lang::Throwable%> abgeleitet

en: type %qT is not derived from type %qT
de: Typ %qT ist nicht vom Typ %qT abgeleitet

en: type %qT of template argument %qE depends on a template parameter | type %qT of template argument %qE depends on template parameters
de[0]: Typ %qT des Templatearguments %qE hängt von Templateparameter ab
de[1]: Typ %qT des Templatearguments %qE hängt von Templateparametern ab

en: type %qT with no linkage used to declare function %q#D with linkage
de: Typ %qT ohne Bindung für Funktionsdeklaration %q#D mit Bindung deklariert

en: type %qT with no linkage used to declare variable %q#D with linkage
de: Typ %qT ohne Bindung verwendet, um Variable %q#D mit Bindung zu deklarieren

en: type %qs does not conform to the %qE protocol
de: Typ %qs entspricht nicht dem Protokoll %qE

en: type assertion only valid for interface types
de: Typbehauptung nur gültig für Schnittstellentypen

en: type attributes ignored after type is already defined
de: Typattribute ignoriert, nachdem Typ bereits definiert ist

en: type defaults to %<int%> in declaration of %qE
de: %<int%> ist Standardtyp in Deklaration von %qE

en: type defaults to %<int%> in type name
de: %<int%> ist Standardtyp in Typ-Deklaration

en: type has no methods
de: Typ hat keine Methoden

en: type is deprecated
de: Typ ist veraltet

en: type is deprecated (declared at %s:%d)
de: Typ ist veraltet (deklariert bei %s:%d)

en: type is deprecated (declared at %s:%d): %s
de: Typ ist veraltet (deklariert bei %s:%d): %s

en: type is deprecated: %s
de: Typ ist veraltet: %s

en: type mismatch between an SSA_NAME and its symbol
de: Unpassende Typen für SSA_NAME und sein Symbol

en: type mismatch in address expression
de: Typ passt nicht in Adressausdruck

en: type mismatch in array range reference
de: Typ passt nicht in Feldbereichsreferenz

en: type mismatch in array reference
de: Typ passt nicht in Feldreferenz

en: type mismatch in binary expression
de: Typ passt nicht in binärem Ausdruck

en: type mismatch in binary truth expression
de: Typ passt nicht in binärem Wahrheitsausdruck

en: type mismatch in comparison expression
de: Typ passt nicht in Vergleichsausdruck

en: type mismatch in complex expression
de: Typ passt nicht in komplexem Ausdruck

en: type mismatch in component reference
de: Typ passt nicht in Komponentenreferenz

en: type mismatch in conditional expression
de: Typ passt nicht in bedingtem Ausdruck

en: type mismatch in fused multiply-add expression
de: Typ passt nicht in vereinigtem Multiplizier-Addier-Ausdruck

en: type mismatch in nontype parameter pack
de: Typ passt nicht in Nichttypen-Parameterbündel

en: type mismatch in pointer plus expression
de: Typ passt nicht in Pointeradditionsausdruck

en: type mismatch in real/imagpart reference
de: Typ passt nicht in Referenz auf realen/imaginären Anteil

en: type mismatch in shift expression
de: Typ passt nicht in Schiebeausdruck

en: type mismatch in vector shift expression
de: Typ passt nicht in Vektorschiebeausdruck

en: type mismatch in widening multiply-accumulate expression
de: Typ passt nicht in verbreiterndem Multiplizier-Akkumulier-Ausdruck

en: type mismatch with previous external decl of %q#D
de: Typen passen nicht zu vorheriger externer Deklaration von %q#D

en: type name declared as function returning a function
de: Typname als Funktion, die eine Funktion zurückgibt, deklariert

en: type name declared as function returning an array
de: Typname als Funktion, die ein Feld zurückgibt, deklariert

en: type of %qD defaults to %<int%>
de: Typ von %qD ist auf %<int%> voreingestellt

en: type of %qD does not match original declaration
de: Typ von %qD passt nicht zur ursprünglichen Deklaration

en: type of %qE is unknown
de: Typ von %qE ist unbekannt

en: type of array %q+D completed incompatibly with implicit initialization
de: Typ des Feldes %q+D vervollständigt Unverträglichkeit mit impliziter Initialisierung

en: type of asm operand %qE could not be determined
de: Typ des asm-Operanden %qE konnte nicht ermittelt werden

en: type of bit-field %qs is a GCC extension
de: Typ des Bitfeldes %qs ist eine Erweiterung des GCC

en: type of field declared here
de: Typ des Felds hier deklariert

en: type of formal parameter %d is incomplete
de: Typ des formalen Parameters %d ist unvollständig

en: type of mismatching field declared here
de: Typ des unpassenden Feldes hier deklariert

en: type of property %qD conflicts with previous declaration
de: Typ der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: type qualifiers ignored on function return type
de: Typkennzeichner an Funktions-Rückgabewert ignoriert

en: type qualifiers specified for friend class declaration
de: Typkennzeichner für friend-Klassen-Deklaration angegeben

en: type size can%'t be explicitly evaluated
de: die Typgröße kann nicht explizit ausgewertet werden

en: type to vector delete is neither pointer or array type
de: Typ für Vektor-»delete« ist weder Zeiger- noch Feldtyp

en: type-punning to incomplete type might break strict-aliasing rules
de: Type-Punning auf unvollständigen Typen kann strict-aliasing-Regeln verletzen

en: type/value mismatch at argument %d in template parameter list for %qD
de: Typ/Wert des Arguments %d passt nicht in Template-Parameterliste für %qD

en: typedef %q+D declared %<inline%>
de: typedef %q+D als %<inline%> deklariert

en: typedef %qD is initialized (use __typeof__ instead)
de: typedef %qD ist initialisiert (stattdessen lieber __typeof__ verwenden)

en: typedef %qD is initialized (use decltype instead)
de: typedef %qD ist initialisiert (stattdessen decltype verwenden)

en: typedef declaration invalid in parameter declaration
de: »typedef«-Deklaration in Parameterdeklaration ungültig

en: typedef declared %<auto%>
de: »typedef« als %<auto%> deklariert

en: typedef name may not be a nested-name-specifier
de: typedef-Name darf kein Spezifizierer mit geschachteltem Namen sein

en: typedef-name %qD used as destructor declarator
de: typedef-Name %qD als Destruktor-Deklarator verwendet

en: typeid-expression is not a constant expression because %qE is of polymorphic type
de: Typeid-Ausdruck ist kein konstanter Ausdruck, da %qE polymorphen Typ hat

en: types are not quite compatible
de: Typen nicht ganz kompatibel

en: types may not be defined in %<decltype%> expressions
de: Typen dürfen nicht in %<decltype%>-Ausdrücken definiert werden

en: types may not be defined in %<noexcept%> expressions
de: Typen dürfen nicht in %<noexcept%>-Ausdrücken definiert werden

en: types may not be defined in a %<typeid%> expression
de: Typen dürfen nicht in einem %<typeid%>-Ausdruck definiert werden

en: types may not be defined in a new-type-id
de: Typen dürfen nicht in einem »new-type-id« definiert werden

en: types may not be defined in an exception-specification
de: Typen dürfen nicht in einer Ausnahmespezifikation definiert werden

en: types may not be defined in casts
de: Typen dürfen nicht in Typumwandlungen definiert werden

en: types may not be defined in conditions
de: Typen dürfen nicht in Bedingungen definiert werden

en: types may not be defined in exception-declarations
de: Typen dürfen nicht in Ausnahmedeklarationen definiert werden

en: types may not be defined in parameter types
de: Typen dürfen nicht in Parametertypen definiert werden

en: types may not be defined in template arguments
de: in Template-Argumenten dürfen keine Typen definiert werden

en: unable to compute real location of stacked parameter
de: Wirkliche Stelle des gestapelten Parameters kann nicht berechnet werden

en: unable to deduce %qT from %qE
de: %qT kann nicht aus %qE hergeleitet werden

en: unable to determine the declared type of expression %<%E%>
de: deklarierter Typ des Ausdrucks %<%E%> kann nicht ermittelt werden

en: unable to emulate %qs
de: %qs kann nicht emuliert werden

en: unable to find a register to spill in class %qs
de: in Klasse %qs konnte kein Register für Überlauf gefunden werden

en: unable to generate reloads for:
de: Neuladungen konnten nicht generiert werden für:

en: unable to locate default linker script %qs in the library search paths
de: Standard-Linkerscript %qs kann nicht in den Bibliotheks-Suchpfaden gefunden werden

en: unable to open dynamic dependency '%s'
de: dynamische Abhängigkeit »%s« kann nicht geöffnet werden

en: unable to use '%s' for PIC register
de: »%s« kann nicht für PIC-Register verwendet werden

en: unconditional %2d never executed
de: unbedingtes %2d niemals ausgeführt

en: unconditional %2d taken %s
de: unbedingtes %2d, genommen: %s

en: unconvertible operand %c %qs
de: Operand %c %qs kann nicht umgewandelt werden

en: undeclared selector %qE
de: nicht deklarierter Selektor %qE

en: undefined named operand %qs
de: benannter Operand %qs ist nicht definiert

en: underlying type %<%T%> of %<%T%> must be an integral type
de: zugrunde liegender Typ %<%T%> von %<%T%> muss ein eingebauter Typ sein

en: underlying type mismatch in enum %q#T
de: falsche Zuordnung des zugrunde liegenden Typs in enum %q#T

en: unexpected %d byte cop instruction
de: unerwartete %d-Byte-Cop-Anweisung

en: unexpected ast of kind %s
de: unerwarteter AST der Art %s

en: unexpected attribute
de: unerwartetes Attribut

en: unexpected base-type in cris_print_base
de: unerwarteter Basistyp in cris_print_base

en: unexpected expression %qE of kind %s
de: unerwarteter Ausdruck %qE der Art %s

en: unexpected index-type in cris_print_index
de: unerwarteter Indextyp in cris_print_index

en: unexpected mode %s encountered in picochip_emit_save_register
de: unerwarteter Modus %s in picochip_emit_save_register gefunden

en: unexpected multiplicative operand
de: unerwarteter multiplikativer Operand

en: unexpected operand
de: unerwarteter Operand

en: unexpected side-effects in address
de: unerwartete Seiteneffekte in Adresse

en: unidentifiable call op
de: Unidentifizierbare Aufrufoperation

en: unimplemented functionality
de: nicht implementierte Funktionalität

en: unimplemented-shmedia profiling
de: nicht implementiertes SHmedia-Profiling

en: uninitialized base %qT in %<constexpr%> constructor
de: nicht initialisierte Basis %qT in %<constexpr%>-Konstruktor

en: uninitialized const %qD
de: nicht initialisiertes const %qD

en: uninitialized const %qD is invalid in C++
de: nicht initialisiertes const %qD ist in C++ ungültig

en: uninitialized const in %<new%> of %q#T
de: nicht initialisierte Konstante in %<new%> von %q#T

en: uninitialized const member %qD
de: nicht initialisiertes konstantes Element %qD

en: uninitialized const member in %q#T
de: nicht initialisiertes konstantes Element in %q#T

en: uninitialized const member in %q#T using %<new%> without new-initializer
de: nicht initialisiertes konstantes Element in %q#T verwendet %<new%> ohne new-Initialisierung

en: uninitialized const member in %qT is invalid in C++
de: nicht initialisiertes konstantes Element %qT ist in C++ ungültig

en: uninitialized member %qD in %<constexpr%> constructor
de: nicht initialisiertes Element %qD in %<constexpr%>-Konstruktor

en: uninitialized member %qD with %<const%> type %qT
de: nicht initialisiertes Element %qD mit %<const%>-Typ %qT

en: uninitialized non-static const member %q#D
de: nicht initialisiertes nicht statisches konstantes Element %q#D

en: uninitialized non-static reference member %q#D
de: nicht initialisiertes nicht statisches Referenzelement %q#D

en: uninitialized reference member %qD
de: nicht initialisiertes Referenzelement %qD

en: uninitialized reference member in %q#T
de: nicht initialisiertes Referenzelement in %q#T

en: uninitialized reference member in %q#T using %<new%> without new-initializer
de: nicht initialisiertes Referenzelement in %q#T verwendet %<new%> ohne new-Initialisierung

en: union cannot be made transparent
de: union kann nicht transparent gemacht werden

en: union defined here
de: »union« wurde hier definiert

en: union has no members
de: Union hat keine Elemente

en: union has no named members
de: Union hat keine benannten Elemente

en: union member %q+D with non-trivial %qD
de: Union-Element %q+D mit nichttrivialem %qD

en: unknown #pragma GCC coprocessor %E
de: unbekanntes #pragma GCC coprocessor %E

en: unknown -m%s= option specified: '%s'
de: unbekannte Option für -m%s= angegeben: »%s«

en: unknown -malign-XXXXX option specified: '%s'
de: unbekannte Option -malign-XXXXX angegeben: »%s«

en: unknown -mdebug-%s switch
de: unbekannter Schalter -mdebug-%s

en: unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>
de: unbekanntes Argument %qs für -mtraceback; %<full%>, %<partial%> oder %<none%> erwartet

en: unknown ABI (%s) for %sabi=%s %s
de: unbekanntes ABI (%s) für %sabi=%s %s

en: unknown ABI specified: '%s'
de: unbekanntes ABI angegeben: »%s«

en: unknown CRIS cpu version specification in -mtune= : %s
de: unbekannte CRIS-CPU-Versionsangabe in -mtune= : %s

en: unknown CRIS version specification in -march= or -mcpu= : %s
de: unbekannte CRIS-Versionsangabe in -march= oder -mcpu= : %s

en: unknown IRA algorithm %qs
de: unbekannter IRA-Algorithmus %qs

en: unknown IRA region %qs
de: unbekannte IRA-Region %qs

en: unknown TLS model %qs
de: unbekanntes TLS-Modell %qs

en: unknown action %qE for %<#pragma pack%> - ignored
de: unbekannte Aktion %qE für %<#pragma pack%> - ignoriert

en: unknown array size in delete
de: unbekannte Feldgröße in »delete«

en: unknown callback event registered by plugin %s
de: unbekanntes Callback-Ereignis von Plugin %s registriert

en: unknown cc_attr value
de: Unbekannter Wert für cc_attr

en: unknown conversion type character %qc in format
de: unbekanntes Konvertierungstyp-Zeichen %qc im Format

en: unknown conversion type character 0x%x in format
de: unbekanntes Konvertierungstyp-Zeichen 0x%x im Format

en: unknown demangling style '%s'
de: unbekannter Aufbereitungszustand »%s«

en: unknown dest
de: unbekanntes Ziel

en: unknown excess precision style %qs
de: unbekannte Art überschüssiger Genauigkeit %qs

en: unknown field %qE specified in initializer
de: unbekanntes Feld %qE in Initialisierung angegeben

en: unknown floating point contraction style %qs
de: unbekannte Art der Gleitkomma-Kürzung %qs

en: unknown insn mode
de: unbekannter Befehlsmodus

en: unknown long branch in %s (type %d)
de: unbekannter weiter Sprung in %s (Typ %d)

en: unknown machine mode %qE
de: Unbekannter Maschinenzustand %qE

en: unknown move insn:
de: Falscher Kopierbefehl:

en: unknown operator %qs in %%:version-compare
de: unbekannter Operator %qs in %%:version-compare

en: unknown option after %<#pragma GCC diagnostic%> kind
de: Option hinter %<#pragma GCC diagnostic%> Art unbekannt

en: unknown option for -mrecip=%s
de: unbekannte Option für -mrecip=%s

en: unknown property attribute
de: unbekanntes Eigenschaftsattribut

en: unknown punctuation '%c'
de: unbekanntes Zeichen »%c«

en: unknown register name %qs in %<asm%>
de: unbekannter Registername %qs in %<asm%>

en: unknown register name: %s
de: unbekannter Registername: %s

en: unknown relocation unspec
de: Unbekanntes relocation unspec

en: unknown short branch in %s (type %d)
de: unbekannter kurzer Sprung in %s (Typ %d)

en: unknown spec function %qs
de: unbekannte Spezifikationsfunktion %qs

en: unknown src
de: unbekannte Quelle

en: unknown stack check parameter "%s"
de: unbekannter Stack-Überprüfungsparameter "%s"

en: unknown switch -mlong-double-%s
de: unbekannter Schalter -mlong-double-%s

en: unknown type %s found during Objective-C encoding
de: unbekannter Typ %s bei Objective-C-Kodierung gefunden

en: unknown type name %qE
de: unbekannter Typname: %qE

en: unknown value %qs of -mmacosx-version-min
de: unbekannter Wert %qs von -mmacosx-version-min

en: unknown value %s for -mfpu
de: unbekannter Wert %s für -mfpu

en: unknown vectorization library ABI type (%s) for %sveclibabi=%s %s
de: unbekannter ABI-Typ (%s) in Vektorisierungsbibliothek für %sveclibabi=%s %s

en: unknown vectorization library ABI type (%s) for -mveclibabi= switch
de: unbekannte ABI-Typ (%s) für Vektorisierungsbibliothek bei Schalter -mveclibabi=

en: unnamed field has incomplete type
de: unbenanntes Feld hat unvollständigen Typen

en: unnamed initializer for %qT, which has no base classes
de: unbenannte Initialisierung für %qT, das keine Basisklassen hat

en: unnamed initializer for %qT, which uses multiple inheritance
de: unbenannte Initialisierung für %qT, das Mehrfachvererbung verwendet

en: unnamed struct/union that defines no instances
de: Unbenannte struct/union, die keine Instanzen definiert

en: unnamed variable or field declared void
de: unbenannte Variable oder Feld als »void« deklariert

en: unordered comparison on non-floating point argument
de: ungeordneter Vergleich mit Nicht-Gleitkomma-Argument

en: unreachable bytecode from %d to before %d
de: unerreichbarer Bytecode von %d bis vor %d

en: unreachable bytecode from %d to the end of the method
de: unerreichbarer Bytecode von %d bis an's Ende der Methode

en: unrecogized wide sub-instruction
de: nicht erkannter breiter Teilbefehl

en: unrecognised debug output level "%s"
de: Testausgabestufe »%s« nicht erkannt

en: unrecognizable insn:
de: unerkennbarer Befehl:

en: unrecognized address
de: unerkannte Adresse

en: unrecognized argument '%s' to -mcpu= option
de: unbekanntes Argument »%s« für Option -mcpu=

en: unrecognized argument in option %qs
de: nicht erkanntes Kommandozeilenargument in Option %qs

en: unrecognized argument to --help= option: %q.*s
de: Argument %q.*s für Option --help= nicht erkannt

en: unrecognized argument to -mmcu= option: %qs
de: Argument für Option -mmcu= nicht erkannt: %qs

en: unrecognized command line option "%s"
de: nicht erkannte Kommandozeilenoption »%s«

en: unrecognized command line option %<-fdump-%s%>
de: nicht erkannte Kommandozeilenoption %<-fdump-%s%>

en: unrecognized command line option %qs
de: nicht erkannte Kommandozeilenoption %qs

en: unrecognized format specifier
de: unerkannte Formatangabe

en: unrecognized gcc debugging option: %c
de: GCC-Debuggingoption nicht erkannt: %c

en: unrecognized include_flags 0x%x passed to print_specific_help
de: nicht erkanntes include_flags 0x%x an print_specific_help weitergegeben

en: unrecognized option %<-%s%>
de: nicht erkannte Option %<-%s%>

en: unrecognized register name %qs
de: unbekannter Registername %qs

en: unrecognized section name %qE
de: nicht erkannter Abschnittsname %qE

en: unrecognized supposed constant
de: unerkannte vermutete Konstante

en: unrecognized visibility value %qs
de: unbekannter Sichtbarkeitswert %qs

en: unrecoverable error
de: nicht behebbarer Fehler

en: unreocgnized control register number: %d - using 'psw'
de: unbekannte Steuerregisterzahl: %d - 'psw' wird verwendet

en: unresolved overload for Altivec builtin %qF
de: ungelöste Überladung des eingebauten Altivec %qF

en: unsuffixed float constant
de: Gleitkommakonstante ohne Suffix

en: unsupported argument to %<__builtin_frame_address%>
de: Nicht unterstütztes Argument für %<__builtin_frame_address%>

en: unsupported argument to %<__builtin_return_address%>
de: Nicht unterstütztes Argument für %<__builtin_return_address%>

en: unsupported argument type to builtin function
de: nicht unterstützter Argumenttyp für eingebaute Funktion

en: unsupported combination: %s
de: nicht unterstützte Kombination: %s

en: unsupported non-standard concatenation of string literals
de: nicht unterstützte Nicht-Standard-Verkettung von Zeichenkettenliteralen

en: unsupported non-standard suffix on floating constant
de: nicht unterstützter Nicht-Standard-Suffix an Gleitkommakonstante

en: unsupported operand size for extended register
de: nicht unterstützte Operandengröße für erweitertes Register

en: unterminated assembly dialect alternative
de: unbeendete Assemblerdialekt-Alternative

en: unterminated format string
de: unbeendete Formatzeichenkette

en: unused arguments in $-style format
de: unbenutzte Argumente in $-Stil-Format

en: unused parameter %q+D
de: unbenutzter Parameter %q+D

en: unused variable %q+D
de: Variable %q+D wird nicht verwendet

en: unusual TP-relative address
de: unübliche TP-relative Adresse

en: unwind tables currently require a frame pointer for correctness
de: Abwicklungstabellen erfordern derzeit einen Rahmenzeiger für Korrektheit

en: unwind tables currently require either a frame pointer or %saccumulate-outgoing-args%s for correctness
de: Abwicklungstabellen erfordern derzeit entweder einen Rahmenzeiger oder %saccumulate-outgoing-args%s für Korrektheit

en: unwind tables currently require either a frame pointer or -maccumulate-outgoing-args for correctness
de: Abwicklungstabellen erfordern derzeit entweder einen Rahmenzeiger oder -maccumulate-outgoing-args für Korrektheit

en: upper value in case label range exceeds maximum value for type
de: Oberer Wert in case-Marken-Bereich überschreitet den Maximalwert des Typs

en: use #include instead
de: stattdessen #include verwenden

en: use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name
de: %<%T::%D%> statt %<%T::%D%> verwenden, um den Konstruktor mit qualifiziertem Namen zu benennen

en: use %<%T::template %D%> to indicate that it is a template
de: %<%T::template %D%> verwenden, um dies als Template zu kennzeichnen

en: use %<...%> to expand argument pack
de: %<...%> verwenden, um Argumentpack aufzulösen

en: use -Winvalid-pch for more information
de: -Winvalid-pch für weitere Informationen verwenden

en: use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts
de: -flax-vector-conversions verwenden, um Umwandlung zwischen Vektoren mit unterschiedlichen Elementtypen oder Anzahl der Teile zu erlauben

en: use __attribute__ ((vector_size)) instead
de: Stattdessen __attribute__ ((Vektorgröße)) verwenden

en: use __builtin_rx_mvtc (0, ... ) to write arbitrary values to PSW
de: __builtin_rx_mvtc (0, ... ) verwenden, um beliebige Werte in PSW zu schreiben

en: use of %<auto%> variable from containing function
de: Verwendung einer %<auto%>-Variable aus enthaltender Funktion

en: use of %<complex%> in AltiVec types is invalid
de: Verwendung von %<complex%> in AltiVec-Typen ist ungültig

en: use of %<double%> in AltiVec types is invalid without -mvsx
de: Verwendung von %<double%> in AltiVec-Typen ist ohne -mvsx ungültig

en: use of %<long double%> in AltiVec types is invalid
de: Verwendung von %<long double%> in AltiVec-Typen ist ungültig

en: use of %<long long%> in AltiVec types is invalid without -mvsx
de: Verwendung von %<long long%> in AltiVec-Typen ist ohne -mvsx ungültig

en: use of %<long%> in AltiVec types is deprecated; use %<int%>
de: Verwendung von %<long%> in AltiVec-Typen ist veraltet; %<int%> verwenden

en: use of %<long%> in AltiVec types is invalid for 64-bit code without -mvsx
de: Verwendung von %<long%> in AltiVec-Typen ist für 64-Bit-Code ohne -mvsx ungültig

en: use of %qs in template
de: Verwendung von %qs in Template

en: use of %qs length modifier with %qc type character
de: Verwendung des %qs-Längenmodifizierers mit %qc-Typ-Zeichen

en: use of %s and %s together in %s format
de: gleichzeitige Verwendung von %s und %s im Format %s

en: use of %s and %s together with %<%%%c%> %s format
de: Verwendung von %s und %s zusammen mit Format %<%%%c%> %s

en: use of boolean types in AltiVec types is invalid
de: Verwendung boolescher Typen in AltiVec-Typen ist ungültig

en: use of class template %qT as expression
de: Verwendung des Klassentemplates %qT als Ausdruck

en: use of decimal floating point types in AltiVec types is invalid
de: Verwendung dezimaler Gleitkommatypen in AltiVec-Typen ist ungültig

en: use of deleted function %qD
de: gelöschte Funktion %qD wird verwendet

en: use of enum %q#D without previous declaration
de: Verwendung des enum %q#D ohne vorherige Deklaration

en: use of memory input without lvalue in asm operand %d is deprecated
de: die Verwendung einer Speichereingabe ohne L-Wert in asm-Operand %d ist veraltet

en: use of namespace %qD as expression
de: Verwendung des Namensbereiches %qD als Ausdruck

en: use of obsolete %%[ operator in specs
de: Verwendung des veralteten Operators %%[ in Spezifikationen

en: use of old-style cast
de: Verwendung einer Typumwandlung im alten Stil

en: use of parameter %qD outside function body
de: Verwendung des Parameters %qD außerhalb des Funktionskörpers

en: use of the value of the object being constructed in a constant expression
de: Verwendung des Wertes des konstruierten Objektes in konstantem Ausdruck

en: use of type %<%E%> with two mismatching declarations at field %<%E%>
de: Verwendung des Typs %<%E%> mit zwei unpassenden Deklarationen bei Feld %<%E%>

en: use option -std=c99 or -std=gnu99 to compile your code
de: -std=c99 oder -std=gnu99 verwenden, um den Code zu übersetzen

en: use template<> for an explicit specialization
de: template<> für eine explizite Spezialisierung verwenden

en: used array that cannot be converted to pointer where scalar is required
de: Feld, das nicht in Zeiger umgewandelt werden kann, anstelle des geforderten Skalars verwendet

en: used struct type value where scalar is required
de: Wert eines struct-Typs anstelle des geforderten Skalars verwendet

en: used union type value where scalar is required
de: Wert eines union-Typs anstelle des geforderten Skalars verwendet

en: useless %<__thread%> in empty declaration
de: Nutzloses %<__thread%> in leerer Deklaration

en: useless storage class specifier in empty declaration
de: Nutzlose Speicherklassenangabe in leerer Deklaration

en: useless type name in empty declaration
de: Nutzloser Typname in leerer Deklaration

en: useless type qualifier in empty declaration
de: Nutzloser Typqualifizierer in leerer Deklaration

en: user-defined %qD always evaluates both arguments
de: benutzerdefiniertes %qD wertet immer beide Argumente aus

en: using %<%c%s%>
de: %<%c%s%> wird verwendet

en: using IBM extended precision long double
de: IBM long double mit erweiterter Genauigkeit wird verwendet

en: using IEEE extended precision long double
de: IEEE long double mit erweiterter Genauigkeit wird verwendet

en: using both @FILE with multiple files not implemented
de: Verwendung von @FILE mit mehreren Dateien ist nicht implementiert

en: using darwin64 ABI
de: darwin64-ABI wird verwendet

en: using declaration %q+D conflicts with a previous using declaration
de: Using-Deklaration %q+D in Konflikt mit vorheriger using-Deklaration

en: using invalid field %qD
de: ungültiges Feld %qD wird verwendet

en: using old darwin ABI
de: Altes darwin-ABI wird verwendet

en: using result of function returning %<void%>
de: Ergebnis einer %<void%> zurückgebenden Funktion verwendet

en: using template type parameter %qT after %qs
de: Templatetyp-Parameter %qT wird nach %qs verwendet

en: using temporary as lvalue
de: temporärer Wert wird als L-Wert verwendet

en: using typedef-name %qD after %qs
de: typedef-Name %qD wird nach %qs verwendet

en: using xvalue (rvalue reference) as lvalue
de: X-Wert (R-Wert-Referenz) wird als L-Wert verwendet

en: using-declaration for non-member at class scope
de: »using«-Deklaration für Nicht-Element im Gültigkeitsbereich der Klasse

en: valid arguments to %qs are: %s
de: gültige Argumente für %qs sind: %s

en: validate_value_data: Loop in regno chain (%u)
de: validate_value_data: Zyklus in regno-Kette (%u)

en: validate_value_data: [%u] Bad next_regno for empty chain (%u)
de: validate_value_data: [%u] Falsches next_regno für leere Kette (%u)

en: validate_value_data: [%u] Bad oldest_regno (%u)
de: validate_value_data: [%u] Falsches oldest_regno (%u)

en: validate_value_data: [%u] Non-empty reg in chain (%s %u %i)
de: validate_value_data: [%u] Nicht leeres Register in Kette (%s %u %i)

en: value computed is not used
de: berechneter Wert ist unbenutzt

en: value of -mfixed-range must have form REG1-REG2
de: Wert von -mfixed-range muss die Form REG1-REG2 haben

en: value passed to %<-m%s%> is too large
de: an %<-m%s%> übergebener Wert ist zu groß

en: value-initialization of %q#D, which has reference type
de: Wertinitialisierung von %q#D, das Referenztyp hat

en: value-initialization of reference
de: Wert-Initialisierung von Referenz

en: var-tracking-assignments changes selective scheduling
de: var-tracking-assignments ändert selektive Planung

en: variable %D of type %<cb%> must be uninitialized
de: Variable %D des Typs %<cb%> muss uninitialisiert sein

en: variable %D of type %<io%> must be uninitialized
de: Variable %D des Typs %<io%> muss uninitialisiert sein

en: variable %q#D has initializer but incomplete type
de: Variable %q#D hat Initialisierung, aber unvollständigen Typ

en: variable %q#D with %<auto%> type used in its own initializer
de: Variable %q#D mit %<auto%>-Typ in ihrer eigenen Initialisierung verwendet

en: variable %q+D declared %<inline%>
de: Variable %q+D als %<inline%> deklariert

en: variable %q+D definition is marked dllimport
de: Variablendefinition von %q+D ist als dllimport markiert

en: variable %q+D might be clobbered by %<longjmp%> or %<vfork%>
de: Variable %q+D könnte von »longjmp« oder »vfork« zerstört werden

en: variable %q+D set but not used
de: Variable %q+D gesetzt, aber nicht verwendet

en: variable %qD has function type
de: Variable %qD hat Funktionstyp

en: variable %qD has initializer but incomplete type
de: Variable %qD hat Initialisierung, aber unvollständigen Typ

en: variable %qD redeclared as function
de: Variable %qD als Funktion redeklariert

en: variable %qD set but not used
de: Variable %qD gesetzt, aber nicht verwendet

en: variable %qE of incomplete type %qT will not be accessed in for increment expression
de: auf Variable %qE des unvollständigen Typs %qT wird in Erhöhungsausdruck nicht zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in left operand of comma operator
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im linken Operanden des Kommaoperators zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in right operand of comma operator
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im rechten Operanden des Kommaoperators zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in second operand of conditional expression
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im zweiten Operanden des bedingten Ausdrucks zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in statement
de: auf Variable %qE des unvollständigen Typs %qT wird in Anweisung nicht zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in third operand of conditional expression
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im dritten Operanden des bedingten Ausdrucks zugegriffen

en: variable %s (%ld bytes) is too large for the %s section (%d bytes)
de: Variable %s (%ld Bytes) ist zu groß für Abschnitt %s (%d Bytes)

en: variable length array %qD is used
de: Feld %qD variabler Länge wird verwendet

en: variable length array %qE is used
de: Feld %qE variabler Größe wird verwendet

en: variable length array is used
de: Feld variabler Größe wird verwendet

en: variable or field %qE declared void
de: Variable oder Feld %qE als »void« deklariert

en: variable or field declared void
de: Variable oder Feld als »void« deklariert

en: variable previously declared %<static%> redeclared %<extern%>
de: als %<extern%> redeklarierte Variable war bereits als %<static%> deklariert

en: variable tracking requested, but not supported by this debug format
de: Variablenverfolgung angefordert, jedoch nicht von diesem Debug-Format unterstützt

en: variable tracking requested, but useless unless producing debug info
de: Variablenverfolgung angefordert, jedoch nutzlos ohne Debug-Info

en: variable-size type declared outside of any function
de: Typ mit variabler Größe wurde außerhalb einer Funktion definiert

en: variable-sized compound literal
de: zusammengesetztes Literal variabler Größe

en: variable-sized object %qD may not be initialized
de: Objekt %qD variabler Größe kann nicht initialisiert werden

en: variable-sized object may not be initialized
de: Objekt variabler Größe darf nicht initialisiert werden

en: variably modified %qE at file scope
de: variabel modifiziertes %qE im Dateibereich

en: variably modified field at file scope
de: variabel modifiziertes Feld im Dateibereich

en: variadic functions must use the base AAPCS variant
de: variadische Funktionen müssen die AAPCS-Basisvariante verwenden

en: variadic templates only available with -std=c++0x or -std=gnu++0x
de: variadische Templates nur mit -std=c++0x oder -std=gnu++0x verfügbar

en: vec_extract only accepts 2 arguments
de: vec_extract akzeptiert nur 2 Argumente

en: vec_insert only accepts 3 arguments
de: vec_insert akzeptiert nur 3 Argumente

en: vector %s %s domain error, in %s at %s:%u
de: Bereichsfehler im Vektor %s %s, in %s bei %s:%u

en: vector overflow in expression
de: Vektorüberlauf in Ausdruck

en: vector permutation (%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d)
de: Vektor-Permutation (%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d)

en: vector permutation (%d %d %d %d %d %d %d %d)
de: Vektor-Permutation (%d %d %d %d %d %d %d %d)

en: vector permutation (%d %d %d %d)
de: Vektor-Permutation (%d %d %d %d)

en: vector permutation (%d %d)
de: Vektor-Permutation (%d %d)

en: vector permutation requires vector constant
de: Vektor-Permutation erfordert Vektorkonstante

en: vector size not an integral multiple of component size
de: Vektorgröße kein ganzzahliges Vielfaches der Komponentengröße

en: verification failed at PC=%d: %s
de: Prüfung bei PC=%d gescheitert: %s

en: verification failed: %s
de: Prüfung gescheitert: %s

en: verify_cgraph_node failed
de: verify_cgraph gescheitert

en: verify_eh_tree failed
de: verify_eh_tree gescheitert

en: verify_flow_info failed
de: verify_flow_info gescheitert

en: verify_flow_info: Basic block %d succ edge is corrupted
de: verify_flow_info: Nachfolgekante des Basis-Blocks %d ist beschädigt

en: verify_flow_info: Block %i has loop_father, but there are no loops
de: verify_flow_info: Block %i hat loop_father, aber es gibt keine Schleifen

en: verify_flow_info: Block %i lacks loop_father
de: verify_flow_info: Block %i fehlt loop_father

en: verify_flow_info: Duplicate edge %i->%i
de: verify_flow_info: Doppelte Kante %i->%i

en: verify_flow_info: Incorrect blocks for fallthru %i->%i
de: verify_flow_info: Falsche Blöcke für »fallthru« %i->%i

en: verify_flow_info: Incorrect fallthru %i->%i
de: verify_flow_info: Falsches »fallthru« %i->%i

en: verify_flow_info: REG_BR_PROB does not match cfg %wi %i
de: verify_flow_info: REG_BR_PROB passt nicht zu cfg %wi %i

en: verify_flow_info: Wrong count of block %i %i
de: verify_flow_info: Falsche Blockzahl %i %i

en: verify_flow_info: Wrong count of edge %i->%i %i
de: verify_flow_info: Falsche Kantenzahl %i->%i %i

en: verify_flow_info: Wrong frequency of block %i %i
de: verify_flow_info: Falsche Blockfrequenz %i %i

en: verify_flow_info: Wrong probability of edge %i->%i %i
de: verify_flow_info: Falsche Wahrscheinlichkeit der Kante %i->%i %i

en: verify_gimple failed
de: verify_gimple gescheitert

en: verify_histograms failed
de: verify_histograms gescheitert

en: verify_ssa failed
de: verify_ssa gescheitert

en: verify_stmts failed
de: verify_stmts gescheitert

en: version attribute is not a string
de: Versionsattribut ist keine Zeichenkette

en: virtual SSA name for non-VOP decl
de: virtueller SSA-Name für Nicht-VOP-Deklaration

en: virtual base %qT inaccessible in %qT due to ambiguity
de: virtuelle Basis %qT ist in %qT durch Mehrdeutigkeit unzugänglich

en: virtual functions cannot be friends
de: virtuelle Funktionen können keine friends sein

en: virtual non-class function %qs
de: virtuelle Nicht-Klassen-Funktion %qs

en: visibility argument must be one of "default", "hidden", "protected" or "internal"
de: Sichtbarkeitsargument muss »default«, »hidden«, »protected« oder »internal« sein

en: visibility argument not a string
de: Sichtbarkeitsargument ist keine Zeichenkette

en: visibility attribute not supported in this configuration; ignored
de: Sichtbarkeitsattribute werden in dieser Konfiguration nicht unterstützt; ignoriert

en: void value not ignored as it ought to be
de: void-Wert nicht ignoriert wie es sein sollte

en: volatile must be specified on any memory that is effected by DMA
de: volatile muss für jeden Speicher angegeben werden, der von DMA beeinflusst wird

en: vtable for
de: vtable für

en: vtable layout for class %qT may not be ABI-compliantand may change in a future version of GCC due to implicit virtual destructor
de: vtable-Anordnung für Klasse %qT könnte ABI-unverträglich sein und sich in zukünftigen GCC-Versionen durch implizite virtuelle Destruktoren ändern

en: warning:
de: Warnung:

en: warning: consider linking with '-static' as system libraries with
de: Warnung: Evtl. mit »-static« linken, da Systembibliotheken mit

en: weak %q+D cannot be defined %qE
de: schwaches %q+D kann nicht als %qE definiert werden

en: weak declaration of %q+D must be public
de: schwache Deklaration von %q+D muss öffentlich sein

en: weak declaration of %q+D not supported
de: schwache Deklaration von %q+D wird nicht unterstützt

en: weakref %q+D must have static linkage
de: schwache Referenz %q+D muss statische Bindung haben

en: weakref %q+D ultimately targets itself
de: weakref %q+D zielt letztendlich auf sich selbst ab

en: weakref attribute must appear before alias attribute
de: Attribut weakref muss vor Attribut alias auftreten

en: weakref is not supported in this configuration
de: weakref wird in dieser Konfiguration nicht unterstützt

en: when a volatile object spans multiple type-sized locations, the compiler must choose between using a single mis-aligned access to preserve the volatility, or using multiple aligned accesses to avoid runtime faults; this code may fail at runtime if the hardware does not allow this access
de: wenn ein »volatile«-Objekt über mehrere Bereiche mit Typgröße geht, muss der Compiler wählen zwischen der Verwendung einzelner falsch ausgerichteter Zugriffe um die Volatilität zu erhalten und der Verwendung mehrerer ausgerichteter Zugriffe um Laufzeitfehler zu verhindern. Dies kann zur Laufzeit fehlschlagen, wenn die Hardware diesen Zugriff nicht erlaubt

en: when writing output to %s: %m
de: beim Schreiben der Ausgabe nach %s: %m

en: wide character array initialized from incompatible wide string
de: Feld von wide character mit unverträglicher wide-Zeichenkette initialisiert

en: wide character array initialized from non-wide string
de: Feld von wide character mit Nicht-wide-Zeichenkette initialisiert

en: wide string literal in %<asm%>
de: Wide-Zeichenkettenliteral in %<asm%>

en: width of %q+D exceeds its type
de: Breite von %q+D übersteigt seinen Typen

en: width of %qs exceeds its type
de: Breite von %qs überschreitet dessen Typen

en: width of bit-field %qD has non-integral type %qT
de: Breite des Bit-Feldes %qD hat Nicht-Ganzzahl-Typ %qT

en: will be assumed to return %<id%> and accept
de: werden als %<id%> zurückgebend angenommen und akzeptieren

en: with
de: mit

en: with %q+#D
de: mit %q+#D

en: within this context
de: in diesem Zusammenhang

en: work-sharing region may not be closely nested inside of work-sharing, critical, ordered, master or explicit task region
de: arbeitsteilende Region darf nicht in arbeitsteilender, kritischer, geordneter, Master- oder »explicit task«-Region eng geschachtelt sein

en: writing into constant object (argument %d)
de: Schreiben in konstantes Objekt (Argument %d)

en: writing through null pointer (argument %d)
de: Schreiben über Null-Zeiger (Argument %d)

en: wrong amount of branch edges after conditional jump %i
de: falsche Summe der Zweig-Kanten nach bedingtem Sprung %i

en: wrong amount of branch edges after unconditional jump %i
de: falscher Betrag der Zweig-Kanten nach unbedingtem Sprung %i

en: wrong edge %d->%d for PHI argument
de: Falsche Kante %d->%d für PHI-Argument

en: wrong immediate use list
de: Falsche Liste zur sofortigen Verwendung

en: wrong insn in the fallthru edge
de: falscher Befehl in »fallthru«-Kante

en: wrong list of exited loops for edge  %d->%d
de: Falsche Liste der beendeten Schleifen für Kante %d->%d

en: wrong number of arguments specified for %qE attribute
de: Falsche Anzahl an Argumenten für das Attribut %qE angegeben

en: wrong number of arguments to function %<__builtin_next_arg%>
de: falsche Anzahl der Argumente für Funktion %<__builtin_next_arg%>

en: wrong number of arguments to function %<va_start%>
de: falsche Anzahl der Argumente für Funktion %<va_start%>

en: wrong number of branch edges after unconditional jump %i
de: falsche Anzahl der Zweig-Kanten nach unbedingtem Sprung %i

en: wrong number of template arguments (%d, should be %d or more)
de: falsche Anzahl der Templateargumente (%d, sollte %d oder mehr sein)

en: wrong number of template arguments (%d, should be %d)
de: falsche Anzahl der Templateargumente (%d, sollte %d sein)

en: wrong outgoing edge flags at end of bb %d
de: Falsche ausgehende Kantenmarken am Ende des bb %d

en: wrong type argument to %s
de: Argument falschen Typs für %s

en: wrong type argument to abs
de: Argument falschen Typs für abs

en: wrong type argument to bit-complement
de: Argument falschen Typs für Bit-Komplement

en: wrong type argument to conjugation
de: Argument falschen Typs für Konjugation

en: wrong type argument to decrement
de: Argument falschen Typs für Dekrementierung

en: wrong type argument to increment
de: Argument falschen Typs für Inkrementierung

en: wrong type argument to unary exclamation mark
de: Argument falschen Typs für unäres Ausrufungszeichen

en: wrong type argument to unary minus
de: Argument falschen Typs für unäres Minus

en: wrong type argument to unary plus
de: Argument falschen Typs für unäres Plus

en: x87 register return with x87 disabled
de: x87-Registerrückgabe mit ausgeschaltetem x87

en: xstormy16_print_operand: unknown code
de: xstormy16_print_operand: unbekannter Code

en: z/Architecture
de: z/Architektur

en: z/Architecture mode not supported on %s
de: z/Architektur-Modus nicht unterstützt auf %s

en: zero or negative size array %q+D
de: Feldgröße von %q+D ist null oder negativ

en: zero vector size
de: Vektorgröße Null

en: zero width for bit-field %q+D
de: Breite Null für Bitfeld %q+D

en: zero width for bit-field %qs
de: Breite Null für Bitfeld %qs

en: zero width in %s format
de: Breite null im Format %s

en: zero-length %s format string
de: Format-Zeichenkette %s der Länge null

en: zero-size array %qD
de: Feld %qD der Größe null

en: {anonymous}
de: {anonym}

en: {unknown}
de: {unbekannt}
