gcc-4.4 - en to unknown language translation catalogue (438 entries)

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
target:   -x <language>            Specify the language of the following input files
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behaviour of
                               guessing the language based on the file's extension

en:   crosses initialization of %q+#D
target:   crosses initialisation of %q+#D

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

en:   skips initialization of %q+#D
target:   skips initialisation of %q+#D

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: %<#pragma GCC optimize (string [,string]...)%> does not have a final %<)%>.
target: %<#pragma GCC optimise (string [,string]...)%> does not have a final %<)%>.

en: %<-gnat%> misspelled as %<-gant%>
target: %<-gnat%> mis-spelt as %<-gant%>

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: %Han explicit specialization must be preceded by %<template <>%>
target: %Han explicit specialisation must be preceded by %<template <>%>

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

en: %Hexpected iteration declaration or initialization
target: %Hexpected iteration declaration or initialisation

en: %Hexplicit template specialization cannot have a storage class
target: %Hexplicit template specialisation cannot have a storage class

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

en: %Honly constructors take base initializers
target: %Honly constructors take base initialisers

en: %Htemplate specialization with C linkage
target: %Htemplate specialisation with C linkage

en: %J  when initialized here
target: %J  when initialised here

en: %J  you can work around this by removing the initializer
target: %J  you can work around this by removing the initialiser

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

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

en: %Jinitializations for multiple members of %qT
target: %Jinitialisations for multiple members of %qT

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

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

en: %Juninitialized member %qD with %<const%> type %qT
target: %Juninitialised member %qD with %<const%> type %qT

en: %Juninitialized reference member %qD
target: %Juninitialised reference member %qD

en: %Jvalue-initialization of %q#D, which has reference type
target: %Jvalue-initialisation of %q#D, which has reference type

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: %q+D will be initialized after
target: %q+D will be initialised after

en: %q+D:'selectany' attribute applies only to initialized objects
target: %q+D:'selectany' attribute applies only to initialised objects

en: %qD cannot be initialized by a non-constant expression when being declared
target: %qD cannot be initialised by a non-constant expression when being declared

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

en: %qD is thread-local and so cannot be dynamically initialized
target: %qD is thread-local and so cannot be dynamically 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: %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 appears to be a misspelled interrupt handler
target: %qs appears to be a mis-spelt interrupt handler

en: %qs appears to be a misspelled signal handler
target: %qs appears to be a mis-spelt signal handler

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

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: '%s' at %L already is initialized at %L
target: '%s' at %L already is initialised at %L

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: -finit-character=<n> Initialize local character variables to ASCII value n
target: -finit-character=<n> Initialise local character variables to ASCII value n

en: -finit-integer=<n> Initialize local integer variables to n
target: -finit-integer=<n> Initialise local integer variables to n

en: -finit-logical=<true|false> Initialize local logical variables
target: -finit-logical=<true|false> Initialise local logical variables

en: -finit-real=<zero|nan|inf|-inf> Initialize local real variables
target: -finit-real=<zero|nan|inf|-inf> Initialise local real variables

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: Add a common subexpression elimination pass after loop optimizations
target: Add a common subexpression elimination pass after loop optimisations

en: Allocatable '%s' at %L cannot have an initializer
target: Allocatable '%s' at %L cannot have an initialiser

en: Allow loop optimizations to assume that the loops behave in normal way
target: Allow loop optimisations to assume that the loops behave in normal way

en: Allow math optimizations that may violate IEEE or ISO standards
target: Allow math optimisations that may violate IEEE or ISO standards

en: Allow optimization for floating-point arithmetic which may change the
target: Allow optimisation for floating-point arithmetic which may change the

en: Assume the runtime uses a hash table to map an object to its synchronization structure
target: Assume the runtime uses a hash table to map an object to its synchronisation structure

en: Assumed shape array '%s' at %L is not permitted in an initialization expression
target: Assumed shape array '%s' at %L is not permitted in an initialisation expression

en: Assumed size array '%s' at %L is not permitted in an initialization expression
target: Assumed size array '%s' at %L is not permitted in an initialisation expression

en: Automatic array '%s' at %L cannot have an initializer
target: Automatic array '%s' at %L cannot have an initialiser

en: BB %i can not throw but has EH edges
target: BB %i cannot throw but has EH edges

en: Bad option %s to optimize attribute.
target: Bad option %s to optimise attribute.

en: Bound on number of candidates below that all candidates are considered in iv optimizations
target: Bound on number of candidates below that all candidates are considered in iv optimisations

en: Bound on number of iv uses in loop optimized in iv optimizations
target: Bound on number of iv uses in loop optimised in iv optimisations

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check
target: Bound on number of runtime checks inserted by the vectoriser's loop versioning for alias check

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check
target: Bound on number of runtime checks inserted by the vectoriser's loop versioning for alignment check

en: Bound on size of expressions used in the scalar evolutions analyzer
target: Bound on size of expressions used in the scalar evolutions analyser

en: Can not find a valid counter:value pair:
target: Cannot find a valid counter:value pair:

en: Compare the results of several data dependence analyzers.
target: Compare the results of several data dependence analysers.

en: Component '%s' is initialized twice in the structure constructor at %C!
target: Component '%s' is initialised twice in the structure constructor at %C!

en: Component initializer without name after component named %s at %C!
target: Component initialiser without name after component named %s at %C!

en: Deferred array '%s' at %L is not permitted in an initialization expression
target: Deferred array '%s' at %L is not permitted in an initialisation expression

en: Deprecated in favor of -std=c99
target: Deprecated in favour of -std=c99

en: Deprecated in favor of -std=gnu99
target: Deprecated in favour of -std=gnu99

en: Deprecated in favor of -std=iso9899:1999
target: Deprecated in favour of -std=iso9899:1999

en: Derived type variable '%s' at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON
target: Derived type variable '%s' at %L with default initialisation cannot be in EQUIVALENCE with a variable in COMMON

en: Derived type variable '%s' in COMMON at %L may not have default initializer
target: Derived type variable '%s' in COMMON at %L may not have default initialiser

en: Disable floating point optimizations that ignore the IEEE signedness of zero
target: Disable floating point optimisations that ignore the IEEE signedness of zero

en: Disable optimizations observable by IEEE signaling NaNs
target: Disable optimisations observable by IEEE signaling NaNs

en: Disable optimizations that assume default FP rounding behavior
target: Disable optimisations that assume default FP rounding behaviour

en: Display descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params
target: Display descriptions of a specific class of options.  <class> is one or more of optimisers, target, warnings, undocumented, params

en: Do not generate thread-safe code for initializing local statics
target: Do not generate thread-safe code for initialising local statics

en: Do not perform optimizations increasing noticeably stack usage
target: Do not perform optimisations increasing noticeably stack usage

en: Do not put uninitialized globals in the common section
target: Do not put uninitialised globals in the common section

en: Do not serialize volatile memory references with MEMW instructions
target: Do not serialise volatile memory references with MEMW instructions

en: Do the full register move optimization pass
target: Do the full register move optimisation pass

en: Don't optimize block moves
target: Don't optimise block moves

en: Dummy '%s' at %L cannot have an initializer
target: Dummy '%s' at %L cannot have an initialiser

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

en: Enable Objective-C exception and synchronization syntax
target: Enable Objective-C exception and synchronisation syntax

en: Enable SSA dead code elimination optimization on trees
target: Enable SSA dead code elimination optimisation on trees

en: Enable SSA-CCP optimization on trees
target: Enable SSA-CCP optimisation on trees

en: Enable SSA-PRE optimization on trees
target: Enable SSA-PRE optimisation on trees

en: Enable automatic parallelization of loops
target: Enable automatic parallelisation of loops

en: Enable common options for generating profile info for profile feedback directed optimizations
target: Enable common options for generating profile info for profile feedback directed optimisations

en: Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=
target: Enable common options for generating profile info for profile feedback directed optimisations, and set -fprofile-dir=

en: Enable common options for performing profile feedback directed optimizations
target: Enable common options for performing profile feedback directed optimisations

en: Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=
target: Enable common options for performing profile feedback directed optimisations, and set -fprofile-dir=

en: Enable dominator optimizations
target: Enable dominator optimisations

en: Enable label alignment optimizations
target: Enable label alignment optimisations

en: Enable linker optimizations
target: Enable linker optimisations

en: Enable loop optimizations on tree level
target: Enable loop optimisations on tree level

en: Enable loop vectorization on trees
target: Enable loop vectorisation on trees

en: Enable loop versioning when doing loop vectorization on trees
target: Enable loop versioning when doing loop vectorisation on trees

en: Enable machine specific peephole optimizations
target: Enable machine specific peephole optimisations

en: Enable nested conditional execution optimizations
target: Enable nested conditional execution optimisations

en: Enable optimization of static class initialization code
target: Enable optimisation of static class initialisation code

en: Enable optimizing &&/|| in conditional execution
target: Enable optimising &&/|| in conditional execution

en: Enable use of cost model in vectorization
target: Enable use of cost model in vectorisation

en: Enables a register move optimization
target: Enables a register move optimisation

en: Expected a right parenthesis in expression at %C
target: Expected a right bracket (parenthesis) in expression 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: Extension: BOZ literal at %L used to initialize non-integer variable '%s'
target: Extension: BOZ literal at %L used to initialise non-integer variable '%s'

en: Extension: Evaluation of nonstandard initialization expression at %L
target: Extension: Evaluation of nonstandard initialisation expression at %L

en: Extension: Old-style initialization at %C
target: Extension: Old-style initialisation at %C

en: Extension: initialization of common block variable '%s' in DATA statement at %C
target: Extension: initialisation of common block variable '%s' in DATA statement at %C

en: Extension: re-initialization of '%s' at %L
target: Extension: re-initialisation of '%s' at %L

en: External '%s' at %L cannot have an initializer
target: External '%s' at %L cannot have an initialiser

en: External object '%s' at %L may not have an initializer
target: External object '%s' at %L may not have an initialiser

en: Finalization at %L is not yet implemented
target: Finalisation at %L is not yet implemented

en: Fortran 2003: Elemental function as initialization expression with non-integer/non-character arguments at %L
target: Fortran 2003: Elemental function as initialisation expression with non-integer/non-character arguments at %L

en: Fortran 2003: Function '%s' as initialization expression at %L
target: Fortran 2003: Function '%s' as initialisation expression at %L

en: Fortran 2003: Noninteger exponent in an initialization expression at %L
target: Fortran 2003: Noninteger exponent in an initialisation expression at %L

en: Function '%s' at %L cannot have an initializer
target: Function '%s' at %L cannot have an initialiser

en: Function '%s' in initialization expression at %L must be an intrinsic or a specification function
target: Function '%s' in initialisation expression at %L must be an intrinsic or a specification function

en: Function result '%s' at %L cannot have an initializer
target: Function result '%s' at %L cannot have an initialiser

en: Generate inline floating point division, optimize for latency
target: Generate inline floating point division, optimise for latency

en: Generate inline floating point division, optimize for throughput
target: Generate inline floating point division, optimise for throughput

en: Generate inline integer division, optimize for latency
target: Generate inline integer division, optimise for latency

en: Generate inline integer division, optimize for throughput
target: Generate inline integer division, optimise for throughput

en: Generate inline square root, optimize for latency
target: Generate inline square root, optimise for latency

en: Generate inline square root, optimize for throughput
target: Generate inline square root, optimise for throughput

en: Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed
target: Generate special Objective-C methods to initialise/destroy non-POD C++ ivars, if needed

en: Graphite loop optimizations cannot be used
target: Graphite loop optimisations cannot be used

en: ISO C forbids empty initializer braces
target: ISO C forbids empty initialiser 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 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 in array new
target: ISO C++ forbids initialisation in array new

en: ISO C++ forbids initialization of member %qD
target: ISO C++ forbids initialisation of 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 C++ forbids use of initializer list to initialize reference %qD
target: ISO C++ forbids use of initialiser list to initialise reference %qD

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

en: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization
target: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorisation

en: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization
target: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimisation

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 expression didn't reduce %C
target: Initialisation expression didn't reduce %C

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: Initialize local variables to zero (from g77)
target: Initialise local variables to zero (from g77)

en: Initialized symbol '%s' at %C can only be COMMON in BLOCK DATA
target: Initialised symbol '%s' at %C can only be COMMON in BLOCK DATA

en: Initialized variable '%s' at %L is in a blank COMMON but initialization is only allowed in named common blocks
target: Initialised variable '%s' at %L is in a blank COMMON but initialisation is only allowed in named common blocks

en: Initializer not allowed for PARAMETER '%s' at %C
target: Initialiser not allowed for PARAMETER '%s' at %C

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

en: Intrinsic '%s' at %L cannot have an initializer
target: Intrinsic '%s' at %L cannot have an initialiser

en: Intrinsic function %s(%d) not recognized
target: Intrinsic function %s(%d) not recognised

en: Intrinsic function '%s' at %L is not permitted in an initialization expression
target: Intrinsic function '%s' at %L is not permitted in an initialisation expression

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: MMIX Internal: This is not a recognized address
target: MMIX Internal: This is not a recognised address

en: Maximum length of partial antic set when performing tree pre optimization
target: Maximum length of partial antic set when performing tree pre optimisation

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

en: Missing required parentheses before BIND(C) at %C
target: Missing required brackets (parentheses) before BIND(C) at %C

en: Missing right parenthesis at %C
target: Missing right bracket (parenthesis) at %C

en: Missing right parenthesis or comma at %C
target: Missing right bracket (parenthesis) or comma at %C

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

en: No initializer for component '%s' given in the structure constructor at %C!
target: No initialiser for component '%s' given in the structure constructor at %C!

en: Object '%s' at %L must have the SAVE attribute for default initialization of a component
target: Object '%s' at %L must have the SAVE attribute for default initialisation of a component

en: Optimize for space rather than speed
target: Optimise for space rather than speed

en: Optimize induction variables on trees
target: Optimise induction variables on trees

en: Optimize lui/addiu address loads
target: Optimise lui/addiu address loads

en: Optimize sibling and tail recursive calls
target: Optimise sibling and tail recursive calls

en: Optimize tail call instructions in assembler and linker
target: Optimise tail call instructions in assembler and linker

en: Optimize the output for PROCESSOR
target: Optimise the output for PROCESSOR

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 VR4130-specific alignment optimizations
target: Perform VR4130-specific alignment optimisations

en: Perform a number of minor, expensive optimizations
target: Perform a number of minor, expensive optimisations

en: Perform a register copy-propagation optimization pass
target: Perform a register copy-propagation optimisation pass

en: Perform a register renaming optimization pass
target: Perform a register renaming optimisation pass

en: Perform branch target load optimization after prologue / epilogue threading
target: Perform branch target load optimisation after prologue / epilogue threading

en: Perform branch target load optimization before prologue / epilogue threading
target: Perform branch target load optimisation before prologue / epilogue threading

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

en: Perform cross-jumping optimization
target: Perform cross-jumping optimisation

en: Perform jump threading optimizations
target: Perform jump threading optimisations

en: Perform sequence abstraction optimization on RTL
target: Perform sequence abstraction optimisation on RTL

en: Perform structure layout optimizations based
target: Perform structure layout optimisations based

en: Perform variable tracking and also tag variables that are uninitialized
target: Perform variable tracking and also tag variables that are uninitialised

en: Perform whole program optimizations
target: Perform whole program optimisations

en: Pointer initialization at %C requires '=>', not '='
target: Pointer initialisation at %C requires '=>', not '='

en: Pointer initialization requires a NULL() at %C
target: Pointer initialisation requires a NULL() at %C

en: Put uninitialized constants in ROM (needs -membedded-data)
target: Put uninitialised constants in ROM (needs -membedded-data)

en: Put zero initialized data in the bss section
target: Put zero initialised data in the bss section

en: Recognize C++ keywords like "compl" and "xor"
target: Recognise C++ keywords like "compl" and "xor"

en: Recognize GNU-defined keywords
target: Recognise GNU-defined keywords

en: Recognize built-in functions
target: Recognise built-in functions

en: Recognize the "asm" keyword
target: Recognise the "asm" keyword

en: Report on memory allocation before interprocedural optimization
target: Report on memory allocation before interprocedural optimisation

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

en: Set optimization level to <number>
target: Set optimisation level to <number>

en: Set the verbosity level of the vectorizer
target: Set the verbosity level of the vectoriser

en: The --param option recognizes the following as parameters
target: The --param option recognises the following as parameters

en: The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer
target: The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initialiser

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

en: Unrecognized GIMPLE statement during RTL expansion
target: Unrecognised GIMPLE statement during RTL expansion

en: Unrecognized option to -finit-logical: %s
target: Unrecognised option to -finit-logical: %s

en: Unrecognized option to -finit-real: %s
target: Unrecognised option to -finit-real: %s

en: Use Neon quad-word (rather than double-word) registers for vectorization
target: Use Neon quad-word (rather than double-word) registers for vectorisation

en: Use expression value profiles in optimizations
target: Use expression value profiles in optimisations

en: Variable '%s' at %C with an initializer already appears in a DATA statement
target: Variable '%s' at %C with an initialiser already appears in a DATA statement

en: Variable '%s' at %L is in COMMON but only in BLOCK DATA initialization is allowed
target: Variable '%s' at %L is in COMMON but only in BLOCK DATA initialisation is allowed

en: Variable '%s' in common block '%s' at %C can not be bind(c) since it is not global
target: Variable '%s' in common block '%s' at %C cannot be bind(c) since it is not global

en: Warn about missing fields in struct initializers
target: Warn about missing fields in struct initialisers

en: Warn about optimizations that assume that signed overflow is undefined
target: Warn about optimisations that assume that signed overflow is undefined

en: Warn about overriding initializers without side effects
target: Warn about overriding initialisers without side effects

en: Warn about possibly missing braces around initializers
target: Warn about possibly missing braces around initialisers

en: Warn about possibly missing parentheses
target: Warn about possibly missing brackets (parentheses)

en: Warn about uninitialized automatic variables
target: Warn about uninitialised automatic variables

en: Warn about unrecognized pragmas
target: Warn about unrecognised pragmas

en: Warn about variables which are initialized to themselves
target: Warn about variables which are initialised to themselves

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

en: Warn when an optimization pass is disabled
target: Warn when an optimisation pass is disabled

en: Warn when non-templatized friend functions are declared within a template
target: Warn when non-templatised friend functions are declared within a template

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

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 parenthesised string literal %qE

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

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 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: assignment (not initialization) in declaration
target: assignment (not initialisation) in declaration

en: attributes after parenthesized initializer ignored
target: attributes after parenthesised 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 initializer expansion %<%T%> contains no parameter packs
target: base initialiser expansion %<%T%> contains no parameter packs

en: braces around scalar initializer
target: braces around scalar initialiser

en: braces around scalar initializer for type %qT
target: 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: can't initialize friend function %qs
target: can't initialise friend function %qs

en: cannot initialize %qT from %qT
target: cannot initialise %qT from %qT

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 arrays using this syntax
target: cannot initialise arrays using this syntax

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

en: cannot optimize loop, the loop counter may overflow
target: cannot optimise loop, the loop counter may overflow

en: cannot optimize possibly infinite loops
target: cannot optimise possibly infinite loops

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: 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 auto from brace-enclosed initializer list requires #include <initializer_list>
target: deducing auto 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: 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: duplicated initializer
target: duplicated initialiser

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: 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 iteration declaration or initialization
target: expected iteration declaration or initialisation

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: extra brace group at end of initializer
target: extra brace group at end of initialiser

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

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

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: function template partial specialization %qD is not allowed
target: function template partial specialisation %qD is not allowed

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: 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 qualifiers from pointer target type
target: initialisation discards qualifiers 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 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 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 makes qualified function pointer from unqualified
target: initialisation makes qualified function pointer from unqualified

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 string truncated to match variable at %L
target: initialisation string truncated to match variable at %L

en: initialized field overwritten
target: initialised field overwritten

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

en: initialized from %qE
target: initialised from %qE

en: initialized from here
target: initialised from here

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

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 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 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 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 a temporary of type %qT
target: invalid initialisation of non-const reference of type %qT from a temporary 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 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 types
target: invalid value-initialisation of reference types

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: member %qD with uninitialized const fields
target: member %qD with uninitialised const fields

en: missing braces around initializer
target: missing braces around initialiser

en: missing braces around initializer for %qT
target: missing braces around initialiser for %qT

en: missing initializer
target: missing initialiser

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

en: ms_abi attribute requires -maccumulate-outgoing-args or subtarget optimization implying it
target: ms_abi attribute requires -maccumulate-outgoing-args or subtarget optimisation implying it

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

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 size in new, unable to verify length of initializer-list
target: non-constant array size in new, unable to verify length of initialiser-list

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: not yet implemented: latency-optimized inline square root
target: not yet implemented: latency-optimised inline square root

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 initialized variables can be placed into program memory area
target: only initialised variables can be placed into program memory area

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: optimizing for size and code size would grow
target: optimising for size and code size would grow

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

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

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

en: partial specialization %qT does not specialize any template arguments
target: partial specialisation %qT does not specialise any template arguments

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

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 '%c'
target: spec failure: unrecognised spec option '%c'

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 %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: stmt (%p) marked modified after optimization pass:
target: stmt (%p) marked modified after optimisation pass:

en: structure %qD with uninitialized const members
target: structure %qD with uninitialised const members

en: structure %qD with uninitialized reference members
target: structure %qD with uninitialised reference members

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 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: synthesized method %qD first required here
target: synthesised method %qD first required here

en: template header not allowed in member definition of explicitly specialized class
target: template header not allowed in member definition of explicitly specialised class

en: template parameters not used in partial specialization:
target: template parameters not used in partial specialisation:

en: this can result in poorly optimized code
target: this can result in poorly optimised code

en: too many braces around initializer for %qT
target: too many 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: transformational intrinsic '%s' at %L is not permitted in an initialization expression
target: transformational intrinsic '%s' at %L is not permitted in an initialisation expression

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 in %<new%> of %q#T
target: uninitialised const in %<new%> of %q#T

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

en: unknown field %qE specified in initializer
target: unknown field %qE specified in initialiser

en: unknown vectorization library ABI type (%s) for %sveclibabi=%s %s
target: unknown vectorisation library ABI type (%s) for %sveclibabi=%s %s

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: unrecogized wide sub-instruction
target: unrecogised wide sub-instruction

en: unrecognizable insn:
target: unrecognisable insn:

en: unrecognized address
target: unrecognised address

en: unrecognized command line option "%s"
target: unrecognised command line option "%s"

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 option '-%s'
target: unrecognised option '-%s'

en: unrecognized register name "%s"
target: unrecognised register name "%s"

en: unrecognized section name "%s"
target: unrecognised section name "%s"

en: unrecognized supposed constant
target: unrecognised supposed constant

en: unrecognized visibility value "%s"
target: unrecognised visibility value "%s"

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

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

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 %qD may not be initialized
target: variable-sized object %qD may not be initialised

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

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

en: weak declaration of %q+D after first use results in unspecified behavior
target: weak declaration of %q+D after first use results in unspecified behaviour

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
