gcc-7 - en to unknown language translation catalogue (313 entries)

en:   initializing argument %P of %qD
target:   initialising argument %P of %qD

en:   when initialized here
target:   when initialised here

en: #pragma GCC optimize is not allowed inside functions
target: #pragma GCC optimise is not allowed inside functions

en: #pragma GCC optimize string... is badly formed
target: #pragma GCC optimise string... is badly formed

en: %<-gnat%> misspelled as %<-gant%>
target: %<-gnat%> misspelt as %<-gant%>

en: %<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type
target: %<constexpr%> needed for in-class initialisation of static data member %q#D of non-integral type

en: %<inline%> is not allowed in declaration of friend template specialization %qD
target: %<inline%> is not allowed in declaration of friend template specialisation %qD

en: %<weakref%> attribute ignored because variable is initialized
target: %<weakref%> attribute ignored because variable is initialised

en: %q#D is a static data member; it can only be initialized at its definition
target: %q#D is a static data member; it can only be initialised at its definition

en: %qD declared as reference but not initialized
target: %qD declared as reference but not initialised

en: %qD is used uninitialized in this function
target: %qD is used uninitialised in this function

en: %qD may be used uninitialized in this function
target: %qD may be used uninitialised in this function

en: %qD should be initialized
target: %qD should be initialised

en: %qD should be initialized in the member initialization list
target: %qD should be initialised in the member initialisation list

en: %qD used in its own initializer
target: %qD used in its own initialiser

en: %qD was not initialized with a constant expression
target: %qD was not initialised with a constant expression

en: %qE attribute applies only to initialized variables with external linkage
target: %qE attribute applies only to initialised variables with external linkage

en: %qE has both %<extern%> and initializer
target: %qE has both %<extern%> and initialiser

en: %qE initialized and declared %<extern%>
target: %qE initialised and declared %<extern%>

en: %qE is an unrecognized format function type
target: %qE is an unrecognised format function type

en: %qE is not initialized
target: %qE is not initialised

en: %qs has both %<extern%> and initializer
target: %qs has both %<extern%> and initialiser

en: %qs initialized and declared %<extern%>
target: %qs initialised and declared %<extern%>

en: (an out of class initialization is required)
target: (an out of class initialisation is required)

en: (near initialization for %qs)
target: (near initialisation for %qs)

en: (static initializers for %s)
target: (static initialisers for %s)

en: <During initialization>
target: <During initialisation>

en: <brace-enclosed initializer list>
target: <brace-enclosed initialiser list>

en: ASYNCHRONOUS= specifier at %L must be an initialization expression
target: ASYNCHRONOUS= specifier at %L must be an initialisation expression

en: AUX pointer initialized for edge %d->%d
target: AUX pointer initialised for edge %d->%d

en: Can't initialize implied-shape array at %L with scalar
target: Can't initialise implied-shape array at %L with scalar

en: ENUMERATOR %L not initialized with integer expression
target: ENUMERATOR %L not initialised with integer expression

en: Enable link-time optimization.
target: Enable link-time optimisation.

en: Error in pointer initialization at %C
target: Error in pointer initialisation at %C

en: Expected an initialization expression at %C
target: Expected an initialisation expression at %C

en: Expected initialization expression at %C
target: Expected initialisation expression at %C

en: Expected initialization expression in CASE at %C
target: Expected initialisation expression in CASE at %C

en: Expected left parenthesis
target: Expected left bracket (parenthesis)

en: Expected right parenthesis
target: Expected right bracket (parenthesis)

en: Expected scalar initialization expression at %C
target: Expected scalar initialisation expression at %C

en: ISO C forbids empty initializer braces
target: ISO C forbids empty initialiser curly brackets (braces)

en: ISO C forbids initialization between function pointer and %<void *%>
target: ISO C forbids initialisation between function pointer and %<void *%>

en: ISO C forbids specifying range of elements to initialize
target: ISO C forbids specifying range of elements to initialise

en: ISO C++ does not allow designated initializers
target: ISO C++ does not allow designated initialisers

en: ISO C++ forbids braced-groups within expressions
target: ISO C++ forbids curly bracketed-groups within expressions

en: ISO C++ forbids in-class initialization of non-const static member %qD
target: ISO C++ forbids in-class initialisation of non-const static member %qD

en: ISO C++ forbids initialization of member constant %qD of non-integral type %qT
target: ISO C++ forbids initialisation of member constant %qD of non-integral type %qT

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%>
target: ISO C++ forbids taking the address of an unqualified or parenthesised non-static member function to form a pointer to member function.  Say %<&%T::%D%>

en: ISO C90 forbids specifying subobject to initialize
target: ISO C90 forbids specifying subobject to initialise

en: Initialization at %C is not allowed in a PURE procedure
target: Initialisation at %C is not allowed in a PURE procedure

en: Initialization at %C isn't for a pointer variable
target: Initialisation at %C isn't for a pointer variable

en: Initialization of allocatable component at %C is not allowed
target: Initialisation of allocatable component at %C is not allowed

en: Initialization of pointer at %C is not allowed in a PURE procedure
target: Initialisation of pointer at %C is not allowed in a PURE procedure

en: Initialization of variable at %C is not allowed in a PURE procedure
target: Initialisation of variable at %C is not allowed in a PURE procedure

en: Initializing already initialized variable at %C
target: Initialising already initialised variable at %C

en: Invalid initializer %s in Data statement at %C
target: Invalid initialiser %s in Data statement at %C

en: KIND parameter of %s at %L must be an initialization expression
target: KIND parameter of %s at %L must be an initialisation expression

en: Link-time optimization with number of parallel jobs or jobserver.
target: Link-time optimisation with number of parallel jobs or jobserver.

en: MMIX Internal: This is not a recognized address
target: MMIX Internal: This is not a recognised address

en: Missing leading left parenthesis
target: Missing leading left bracket (parenthesis)

en: NULL() initialization at %C is ambiguous
target: NULL() initialisation at %C is ambiguous

en: Overlapping unequal initializers in EQUIVALENCE at %L
target: Overlapping unequal initialisers in EQUIVALENCE at %L

en: PARAMETER at %L is missing an initializer
target: PARAMETER at %L is missing an initialiser

en: Perform conversions of switch initializations.
target: Perform conversions of switch initialisations.

en: Period required in format specifier
target: Full stop (period) required in format specifier

en: Pointer initialization target at %L must have the SAVE attribute
target: Pointer initialisation target at %L must have the SAVE attribute

en: Procedure pointer initialization target at %L may not be a procedure pointer
target: Procedure pointer initialisation target at %L may not be a procedure pointer

en: Run predictive commoning optimization.
target: Run predictive commoning optimisation.

en: Run the link-time optimizer in local transformation (LTRANS) mode.
target: Run the link-time optimiser in local transformation (LTRANS) mode.

en: Run the link-time optimizer in whole program analysis (WPA) mode.
target: Run the link-time optimiser in whole program analysis (WPA) mode.

en: Syntax error: Trailing garbage in END INTERFACE statement at %C
target: Syntax error: Trailing rubbish in END INTERFACE statement at %C

en: Syntax error: Trailing garbage in INTERFACE statement at %C
target: Syntax error: Trailing rubbish in INTERFACE statement at %C

en: The following options control optimizations
target: The following options control optimisations

en: The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.
target: The minimal probability of speculation success (in percent), so that speculative insn will be scheduled.

en: Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer.
target: Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectoriser.

en: Warn if the loop cannot be optimized due to nontrivial assumptions.
target: Warn if the loop cannot be optimised due to non-trivial assumptions.

en: a brace-enclosed initializer is not allowed here
target: a curly bracket (brace)-enclosed initialiser is not allowed here

en: accessing %qD member instead of initialized %qD member in constant expression
target: accessing %qD member instead of initialised %qD member in constant expression

en: ambiguous template specialization %qD for %q+D
target: ambiguous template specialisation %qD for %q+D

en: an explicit specialization must be preceded by %<template <>%>
target: an explicit specialisation must be preceded by %<template <>%>

en: anachronistic old-style base class initializer
target: anachronistic old-style base class initialiser

en: applying #pragma weak %q+D after first use results in unspecified behavior
target: applying #pragma weak %q+D after first use results in unspecified behaviour

en: argument %qs to %<-Wnormalized%> not recognized
target: argument %qs to %<-Wnormalized%> not recognised

en: argument %qs to %<-femit-struct-debug-detailed%> not recognized
target: argument %qs to %<-femit-struct-debug-detailed%> not recognised

en: array %qD initialized by parenthesized string literal %qE
target: array %qD initialised by bracketed string literal %qE

en: array bound forbidden after parenthesized type-id
target: array bound forbidden after bracketed type-id

en: array index in initializer exceeds array bounds
target: array index in initialiser exceeds array bounds

en: array index in initializer is not an integer constant expression
target: array index in initialiser is not an integer constant expression

en: array index in initializer not of integer type
target: array index in initialiser not of integer type

en: array index in non-array initializer
target: array index in non-array initialiser

en: array index range in initializer exceeds array bounds
target: array index range in initialiser exceeds array bounds

en: array initialized from non-constant array expression
target: array initialised from non-constant array expression

en: array initialized from parenthesized string constant
target: array initialised from bracketed (parenthesised) string constant

en: array must be initialized with a brace-enclosed initializer
target: array must be initialised with a brace-enclosed initialiser

en: array of inappropriate type initialized from string constant
target: array of inappropriate type initialised from string constant

en: array used as initializer
target: array used as initialiser

en: assigning to an array from an initializer list
target: assigning to an array from an initialiser list

en: assignment (not initialization) in declaration
target: assignment (not initialisation) in declaration

en: attributes after parenthesized initializer ignored
target: attributes after bracketed initialiser ignored

en: bad array initializer
target: bad array initialiser

en: base %qT will be initialized after
target: base %qT will be initialised after

en: base class %q#T should be explicitly initialized in the copy constructor
target: base class %q#T should be explicitly initialised in the copy constructor

en: base initializer expansion %<%T%> contains no parameter packs
target: base initialiser expansion %<%T%> contains no parameter packs

en: braces around scalar initializer
target: curly brackets (braces) around scalar initialiser

en: braces around scalar initializer for type %qT
target: curly brackets (braces) around scalar initialiser for type %qT

en: branch target register load optimization is not intended to be run twice
target: branch target register load optimisation is not intended to be run twice

en: can not use -mtp=cp15 with 16-bit Thumb
target: cannot use -mtp=cp15 with 16-bit Thumb

en: can not use an object as parameter to a method
target: cannot use an object as parameter to a method

en: cannot convert %qT to %qT in initialization
target: cannot convert %qT to %qT in initialisation

en: cannot expand initializer for member %<%D%>
target: cannot expand initialiser for member %<%D%>

en: cannot initialize aggregate of type %qT with a compound literal
target: cannot initialise aggregate of type %qT with a compound literal

en: cannot initialize multi-dimensional array with initializer
target: cannot initialise multi-dimensional array with initialiser

en: cannot value-initialize array of unknown bound %qT
target: cannot value-initialise array of unknown bound %qT

en: char-array initialized from wide string
target: char-array initialised from wide string

en: comparison with string literal results in unspecified behavior
target: comparison with string literal results in unspecified behaviour

en: constexpr static data member %qD must have an initializer
target: constexpr static data member %qD must have an initialiser

en: converting to %qT from initializer list would use explicit constructor %qD
target: converting to %qT from initialiser list would use explicit constructor %qD

en: declaration of %q#D has %<extern%> and is initialized
target: declaration of %q#D has %<extern%> and is initialised

en: declaration of %q#D has no initializer
target: declaration of %q#D has no initialiser

en: deducing from brace-enclosed initializer list requires #include <initializer_list>
target: deducing from brace-enclosed initialiser list requires #include <initializer_list>

en: default argument specified in explicit specialization
target: default argument specified in explicit specialisation

en: default arguments are not allowed in declaration of friend template specialization %qD
target: default arguments are not allowed in declaration of friend template specialisation %qD

en: default template arguments may not be used in partial specializations
target: default template arguments may not be used in partial specialisations

en: defining explicit specialization %qD in friend declaration
target: defining explicit specialisation %qD in friend declaration

en: duplicate initialization of %qD
target: duplicate initialisation of %qD

en: empty index range in initializer
target: empty index range in initialiser

en: empty scalar initializer
target: empty scalar initialiser

en: enclosing class templates are not explicitly specialized
target: enclosing class templates are not explicitly specialised

en: enum conversion in initialization is invalid in C++
target: enum conversion in initialisation is invalid in C++

en: excess elements in array initializer
target: excess elements in array initialiser

en: excess elements in char array initializer
target: excess elements in char array initialiser

en: excess elements in scalar initializer
target: excess elements in scalar initialiser

en: excess elements in struct initializer
target: excess elements in struct initialiser

en: excess elements in union initializer
target: excess elements in union initialiser

en: excess elements in vector initializer
target: excess elements in vector initialiser

en: expected initializer
target: expected initialiser

en: expected iteration declaration or initialization
target: expected iteration declaration or initialisation

en: expected labeled-statement
target: expected labelled-statement

en: explicit specialization in non-namespace scope %qD
target: explicit specialisation in non-namespace scope %qD

en: explicit specialization of %qD after first use
target: explicit specialisation of %qD after first use

en: explicit specialization of %qD must be introduced by %<template <>%>
target: explicit specialisation of %qD must be introduced by %<template <>%>

en: explicit specialization of non-template %qT
target: explicit specialisation of non-template %qT

en: explicit template specialization cannot have a storage class
target: explicit template specialisation cannot have a storage class

en: expression list treated as compound expression in initializer
target: expression list treated as compound expression in initialiser

en: expression list treated as compound expression in mem-initializer
target: expression list treated as compound expression in mem-initialiser

en: extra brace group at end of initializer
target: extra curly bracket (brace) group at end of initialiser

en: extra elements in scalar initializer
target: extra elements in scalar initialiser

en: fail to initialize plugin %s
target: fail to initialise plugin %s

en: field name not in record or union initializer
target: field name not in record or union initialiser

en: fr30_print_operand: unrecognized %%B code
target: fr30_print_operand: unrecognised %%B code

en: fr30_print_operand: unrecognized %%b code
target: fr30_print_operand: unrecognised %%b code

en: fr30_print_operand: unrecognized %%p code
target: fr30_print_operand: unrecognised %%p code

en: function %q#D is initialized like a variable
target: function %q#D is initialised like a variable

en: function %qD is initialized like a variable
target: function %qD is initialised like a variable

en: in C++98 %qD must be initialized by constructor, not by %<{...}%>
target: in C++98 %qD must be initialised by constructor, not by %<{...}%>

en: in-class initialization of static data member %q#D of non-literal type
target: in-class initialisation of static data member %q#D of non-literal type

en: incompatible types when initializing type %qT using type %qT
target: incompatible types when initialising type %qT using type %qT

en: index value instead of field name in union initializer
target: index value instead of field name in union initialiser

en: initialization discards %qv qualifier from pointer target type
target: initialisation discards %qv qualifier from pointer target type

en: initialization from distinct Objective-C type
target: initialisation from distinct Objective-C type

en: initialization from incompatible pointer type
target: initialisation from incompatible pointer type

en: initialization from pointer to non-enclosed address space
target: initialisation from pointer to non-enclosed address space

en: initialization left-hand side might be a candidate for a format attribute
target: initialisation left-hand side might be a candidate for a format attribute

en: initialization makes %q#v qualified function pointer from unqualified
target: initialisation makes %q#v qualified function pointer from unqualified

en: initialization makes integer from pointer without a cast
target: initialisation makes integer from pointer without a cast

en: initialization makes pointer from integer without a cast
target: initialisation makes pointer from integer without a cast

en: initialization of a flexible array member
target: initialisation of a flexible array member

en: initialization of flexible array member in a nested context
target: initialisation of flexible array member in a nested context

en: initialization of non-const reference type %q#T from rvalue of type %qT
target: initialisation of non-const reference type %q#T from rvalue of type %qT

en: initialization of volatile reference type %q#T from rvalue of type %qT
target: initialisation of volatile reference type %q#T from rvalue of type %qT

en: initializations for multiple members of %qT
target: initialisations for multiple members of %qT

en: initialized field overwritten
target: initialised field overwritten

en: initialized field with side-effects overwritten
target: initialised field with side-effects overwritten

en: initialized variable %q+D is marked dllimport
target: initialised variable %q+D is marked dllimport

en: initializer element is not a constant expression
target: initialiser element is not a constant expression

en: initializer element is not computable at load time
target: initialiser element is not computable at load time

en: initializer element is not constant
target: initialiser element is not constant

en: initializer ends prematurely
target: initialiser ends prematurely

en: initializer fails to determine size of %q+D
target: initialiser fails to determine size of %q+D

en: initializer fails to determine size of %qD
target: initialiser fails to determine size of %qD

en: initializer for %qT must be brace-enclosed
target: initialiser for %qT must be curly bracket (brace)-enclosed

en: initializer for floating value is not a floating constant
target: initialiser for floating value is not a floating constant

en: initializer for integer/fixed-point value is too complicated
target: initialiser for integer/fixed-point value is too complicated

en: initializer invalid for static member with constructor
target: initialiser invalid for static member with constructor

en: initializer provided for function
target: initialiser provided for function

en: initializer specified for non-virtual method %q+D
target: initialiser specified for non-virtual method %q+D

en: initializer specified for static member function %qD
target: initialiser specified for static member function %qD

en: initializer-string for array of chars is too long
target: initialiser-string for array of chars is too long

en: int-array initialized from incompatible wide string
target: int-array initialised from incompatible wide string

en: int-array initialized from non-wide string
target: int-array initialised from non-wide string

en: inter-module optimizations not implemented for C++
target: inter-module optimisations not implemented for C++

en: invalid explicit specialization
target: invalid explicit specialisation

en: invalid in-class initialization of static data member of non-integral type %qT
target: invalid in-class initialisation of static data member of non-integral type %qT

en: invalid initialization of non-const reference of type %qT from an rvalue of type %qT
target: invalid initialisation of non-const reference of type %qT from an rvalue of type %qT

en: invalid initialization of reference of type %qT from expression of type %qT
target: invalid initialisation of reference of type %qT from expression of type %qT

en: invalid initializer
target: invalid initialiser

en: invalid initializer for array member %q#D
target: invalid initialiser for array member %q#D

en: invalid initializer for member function %qD
target: invalid initialiser for member function %qD

en: invalid type %qT as initializer for a vector of type %qT
target: invalid type %qT as initialiser for a vector of type %qT

en: invalid value-initialization of reference type
target: invalid value-initialisation of reference type

en: jump skips variable initialization
target: jump skips variable initialisation

en: keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)
target: keyword %<typename%> not allowed in this context (a qualified member initialiser is implicitly a type)

en: language %s not recognized
target: language %s not recognised

en: language string %<"%E"%> not recognized
target: language string %<"%E"%> not recognised

en: member %qD is uninitialized reference
target: member %qD is uninitialised reference

en: missing braces around initializer
target: missing curly brackets (braces) around initialiser

en: missing braces around initializer for %qT
target: missing curly brackets (braces) around initialiser for %qT

en: missing close brace for named operand
target: missing close curly bracket (brace) for named operand

en: missing close paren
target: missing close bracket

en: missing initializer for member %qD
target: missing initialiser for member %qD

en: missing open paren
target: missing open bracket

en: multiple fields in union %qT initialized
target: multiple fields in union %qT initialised

en: multiple initializations given for %qD
target: multiple initialisations given for %qD

en: multiple initializations given for base %qT
target: multiple initialisations given for base %qT

en: name %qD used in a GNU-style designated initializer for an array
target: name %qD used in a GNU-style designated initialiser for an array

en: name used in a GNU-style designated initializer for an array
target: name used in a GNU-style designated initialiser for an array

en: no field %qD found in union being initialized
target: no field %qD found in union being initialised

en: non-constant array initialization
target: non-constant array initialisation

en: non-constant in-class initialization invalid for static member %qD
target: non-constant in-class initialisation invalid for static member %qD

en: non-constant initialization expression at %L
target: non-constant initialisation expression at %L

en: non-static initialization of a flexible array member
target: non-static initialisation of a flexible array member

en: non-trivial designated initializers not supported
target: non-trivial designated initialisers not supported

en: nonconstant array index in initializer
target: nonconstant array index in initialiser

en: obsolete use of designated initializer with %<:%>
target: obsolete use of designated initialiser with %<:%>

en: obsolete use of designated initializer without %<=%>
target: obsolete use of designated initialiser without %<=%>

en: only constructors take member initializers
target: only constructors take member initialisers

en: only uninitialized variables can be placed in a .bss section
target: only uninitialised variables can be placed in a .bss section

en: only uninitialized variables can be placed in the .noinit section
target: only uninitialised variables can be placed in the .noinit section

en: opaque vector types cannot be initialized
target: opaque vector types cannot be initialised

en: optimization may eliminate reads and/or writes to register variables
target: optimisation may eliminate reads and/or writes to register variables

en: parameter %qD is initialized
target: parameter %qD is initialised

en: parenthesized initialization is not allowed in OpenMP %<for%> loop
target: bracketed (parenthesised) initialisation is not allowed in OpenMP %<for%> loop

en: partial specialization %qT declared %<friend%>
target: partial specialisation %qT declared %<friend%>

en: plugin %s is not licensed under a GPL-compatible license
    %s
target: plugin %s is not licensed under a GPL-compatible licence
    %s

en: pointer targets in initialization differ in signedness
target: pointer targets in initialisation differ in signedness

en: saw %d %<template<>%>, need %d for specializing a member function template
target: saw %d %<template<>%>, need %d for specialising a member function template

en: scalar object %qD requires one element in initializer
target: scalar object %qD requires one element in initialiser

en: spec failure: %<%%*%> has not been initialized by pattern match
target: spec failure: %<%%*%> has not been initialised by pattern match

en: spec failure: unrecognized spec option %qc
target: spec failure: unrecognised spec option %qc

en: specialization %qT after instantiation %qT
target: specialisation %qT after instantiation %qT

en: specialization of %qD after instantiation
target: specialisation of %qD after instantiation

en: specialization of %qD in different namespace
target: specialisation of %qD in different namespace

en: specialization of %qD must appear at namespace scope
target: specialisation of %qD must appear at namespace scope

en: specialization of %qT after instantiation
target: specialisation of %qT after instantiation

en: specialization of implicitly-declared special member function
target: specialisation of implicitly-declared special member function

en: specializing %q#T in different namespace
target: specialising %q#T in different namespace

en: specializing member %<%T::%E%> requires %<template<>%> syntax
target: specialising member %<%T::%E%> requires %<template<>%> syntax

en: stmt (%p) marked modified after optimization pass:
target: stmt (%p) marked modified after optimisation pass:

en: suggest braces around empty body in %<do%> statement
target: suggest curly brackets (braces) around empty body in %<do%> statement

en: suggest braces around empty body in an %<else%> statement
target: suggest curly brackets (braces) around empty body in an %<else%> statement

en: suggest braces around empty body in an %<if%> statement
target: suggest curly brackets (braces) around empty body in an %<if%> statement

en: suggest explicit braces to avoid ambiguous %<else%>
target: suggest explicit curly brackets (braces) to avoid ambiguous %<else%>

en: suggest parentheses around %<&&%> within %<||%>
target: suggest brackets (parentheses) around %<&&%> within %<||%>

en: suggest parentheses around %<+%> in operand of %<&%>
target: suggest brackets (parentheses) around %<+%> in operand of %<&%>

en: suggest parentheses around %<+%> inside %<<<%>
target: suggest brackets (parentheses) around %<+%> inside %<<<%>

en: suggest parentheses around %<+%> inside %<>>%>
target: suggest brackets (parentheses) around %<+%> inside %<>>%>

en: suggest parentheses around %<-%> in operand of %<&%>
target: suggest brackets (parentheses) around %<-%> in operand of %<&%>

en: suggest parentheses around %<-%> inside %<<<%>
target: suggest brackets (parentheses) around %<-%> inside %<<<%>

en: suggest parentheses around %<-%> inside %<>>%>
target: suggest brackets (parentheses) around %<-%> inside %<>>%>

en: suggest parentheses around %<>>%> expression
target: suggest brackets (parentheses) around %<>>%> expression

en: suggest parentheses around arithmetic in operand of %<^%>
target: suggest brackets (parentheses) around arithmetic in operand of %<^%>

en: suggest parentheses around arithmetic in operand of %<|%>
target: suggest brackets (parentheses) around arithmetic in operand of %<|%>

en: suggest parentheses around assignment used as truth value
target: suggest brackets around assignment used as truth value

en: suggest parentheses around comparison in operand of %<!=%>
target: suggest brackets (parentheses) around comparison in operand of %<!=%>

en: suggest parentheses around comparison in operand of %<&%>
target: suggest brackets (parentheses) around comparison in operand of %<&%>

en: suggest parentheses around comparison in operand of %<==%>
target: suggest brackets (parentheses) around comparison in operand of %<==%>

en: suggest parentheses around comparison in operand of %<^%>
target: suggest brackets (parentheses) around comparison in operand of %<^%>

en: suggest parentheses around comparison in operand of %<|%>
target: suggest brackets (parentheses) around comparison in operand of %<|%>

en: suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>
target: suggest brackets (parentheses) around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>

en: suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>
target: suggest brackets (parentheses) around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>

en: switch jumps over variable initialization
target: switch jumps over variable initialisation

en: synthesized method %qD first required here
target: synthesised method %qD first required here

en: target of initialization might be a candidate for a format attribute
target: target of initialisation might be a candidate for a format attribute

en: template specialization of %qD not allowed by ISO C++
target: template specialisation of %qD not allowed by ISO C++

en: template specialization with C linkage
target: template specialisation with C linkage

en: too many braces around initializer for %qT
target: too many curly brackets (braces) around initialiser for %qT

en: too many initializers for %qT
target: too many initialisers for %qT

en: traditional C rejects automatic aggregate initialization
target: traditional C rejects automatic aggregate initialisation

en: traditional C rejects initialization of unions
target: traditional C rejects initialisation of unions

en: try removing the parentheses around the type-id
target: try removing the brackets (parentheses) around the type-id

en: type of array %q+D completed incompatibly with implicit initialization
target: type of array %q+D completed incompatibly with implicit initialisation

en: typedef %qD is initialized (use __typeof__ instead)
target: typedef %qD is initialised (use __typeof__ instead)

en: typedef %qD is initialized (use decltype instead)
target: typedef %qD is initialised (use decltype instead)

en: uninitialized const %qD
target: uninitialised const %qD

en: uninitialized const %qD is invalid in C++
target: uninitialised const %qD is invalid in C++

en: uninitialized const in %<new%> of %q#T
target: uninitialised const in %<new%> of %q#T

en: uninitialized const member in %q#T
target: uninitialised const member in %q#T

en: uninitialized const member in %q#T using %<new%> without new-initializer
target: uninitialised const member in %q#T using %<new%> without new-initialiser

en: uninitialized const member in %qT is invalid in C++
target: uninitialised const member in %qT is invalid in C++

en: uninitialized reference member in %q#T
target: uninitialised reference member in %q#T

en: uninitialized reference member in %q#T using %<new%> without new-initializer
target: uninitialised reference member in %q#T using %<new%> without new-initialiser

en: unknown vectorization library ABI type (%s) for -mveclibabi= switch
target: unknown vectorisation library ABI type (%s) for -mveclibabi= switch

en: unnamed initializer for %qT, which has no base classes
target: unnamed initialiser for %qT, which has no base classes

en: unnamed initializer for %qT, which uses multiple inheritance
target: unnamed initialiser for %qT, which uses multiple inheritance

en: unrecognizable insn:
target: unrecognisable insn:

en: unrecognized address
target: unrecognised address

en: unrecognized argument in option %qs
target: unrecognised argument in option %qs

en: unrecognized argument to --help= option: %q.*s
target: unrecognised argument to --help= option: %q.*s

en: unrecognized command line option %<-fdump-%s%>
target: unrecognised command line option %<-fdump-%s%>

en: unrecognized command line option %qs
target: unrecognised command line option %qs

en: unrecognized format specifier
target: unrecognised format specifier

en: unrecognized gcc debugging option: %c
target: unrecognised gcc debugging option: %c

en: unrecognized include_flags 0x%x passed to print_specific_help
target: unrecognised include_flags 0x%x passed to print_specific_help

en: unrecognized register name %qs
target: unrecognised register name %qs

en: unrecognized section name %qE
target: unrecognised section name %qE

en: unrecognized supposed constant
target: unrecognised supposed constant

en: unrecognized visibility value %qs
target: unrecognised visibility value %qs

en: use template<> for an explicit specialization
target: use template<> for an explicit specialisation

en: variable %q#D has initializer but incomplete type
target: variable %q#D has initialiser but incomplete type

en: variable %qD has initializer but incomplete type
target: variable %qD has initialiser but incomplete type

en: variable-sized object may not be initialized
target: variable-sized object may not be initialised

en: wide character array initialized from incompatible wide string
target: wide character array initialised from incompatible wide string

en: wide character array initialized from non-wide string
target: wide character array initialised from non-wide string
