gcc-4.6 - en to unknown language translation catalogue (566 entries)

en:   -no-canonical-prefixes   Do not canonicalize paths when building relative
                               prefixes to other gcc components
target:   -no-canonical-prefixes   Do not canonicalise paths when building relative
                               prefixes to other gcc components

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

en:   initializing argument %P of %q+D
target:   initialising argument %P 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:   when initialized here
target:   when initialised here

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

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: %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: %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 a valid template argument for type %qT because function %qD has not external linkage
target: %qE is not a valid template argument for type %qT because function %qD has no external linkage

en: %qE is not a valid template argument for type %qT because object %qD has not external linkage
target: %qE is not a valid template argument for type %qT because object %qD has no external linkage

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 misspelt interrupt handler

en: %qs appears to be a misspelled signal handler
target: %qs appears to be a misspelt signal handler

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: '%%l' operand isn't a label
target: '%%l' operand is not a label

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: (static initializers for %s)
target: (static initialisers for %s)

en: *** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.
target: *** WARNING *** there are active plug-ins, do not report this as a bug unless you can reproduce it without enabling any plug-ins.

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

en: -fcoarray=[...]	Specify which coarray parallelization should be used
target: -fcoarray=[...]	Specify which coarray parallelisation should be used

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: -fno-deduce-init-list	disable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list
target: -fno-deduce-init-list	disable deduction of std::initializer_list for a template type parameter from a brace-enclosed initialiser-list

en: -fno-pretty-templates Do not pretty-print template specializations as the template signature followed by the arguments
target: -fno-pretty-templates Do not pretty-print template specialisations as the template signature followed by the arguments

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

en: -ftree-vectorizer-verbose=<number>	Set the verbosity level of the vectorizer
target: -ftree-vectorizer-verbose=<number>	Set the verbosity level of the vectoriser

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

en: -mtune=PROCESSOR	Optimize the output for PROCESSOR
target: -mtune=PROCESSOR	Optimise the output for PROCESSOR

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: 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: 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: 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: Bound on the complexity of the expressions in the scalar evolutions analyzer
target: Bound on the complexity of the expressions in the scalar evolutions analyser

en: Can't USE the same module we're building!
target: Cannot USE the same module we're building!

en: Can't construct ABSTRACT type '%s' at %C
target: Cannot construct ABSTRACT type '%s' at %C

en: Can't convert %s to %s at %L
target: Cannot convert %s to %s at %L

en: Can't delete module file '%s': %s
target: Cannot delete module file '%s': %s

en: Can't delete temporary module file '%s': %s
target: Cannot delete temporary module file '%s': %s

en: Can't find an intrinsic module named '%s' at %C
target: Cannot find an intrinsic module named '%s' at %C

en: Can't find keyword named '%s' in call to '%s' at %L
target: Cannot find keyword named '%s' in call to '%s' at %L

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

en: Can't open file '%s'
target: Cannot open file '%s'

en: Can't open module file '%s' for reading at %C: %s
target: Cannot open module file '%s' for reading at %C: %s

en: Can't open module file '%s' for writing at %C: %s
target: Cannot open module file '%s' for writing at %C: %s

en: Can't overwrite GENERIC '%s' at %L
target: Cannot overwrite GENERIC '%s' at %L

en: Can't rename module file '%s' to '%s': %s
target: Cannot rename module file '%s' to '%s': %s

en: Cause gas to print tomcat statistics
target: Cause gas to print Tomcat statistics

en: Clear the BSS to zero and place zero initialized in BSS
target: Clear the BSS to zero and place zero initialised in BSS

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: Cost at which GCSE optimizations will not constraint the distance an expression can travel
target: Cost at which GCSE optimisations will not constrain the distance an expression can travel

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: 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: Derived-type dummy argument '%s' at %L was declared INTENT(OUT) but was not set and does not have a default initializer
target: Derived-type dummy argument '%s' at %L was declared INTENT(OUT) but was not set and does not have a 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 signalling NaNs

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

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: Don't optimize block moves
target: Don't optimise block moves

en: Don't optimize block moves, use memcpy
target: Don't optimise block moves, use memcpy

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

en: ENTRY result %s can't be a POINTER in FUNCTION %s at %L
target: ENTRY result %s cannot be a POINTER in FUNCTION %s at %L

en: ENTRY result %s can't be an array in FUNCTION %s at %L
target: ENTRY result %s cannot be an array in FUNCTION %s at %L

en: ENTRY result %s can't be of type %s in FUNCTION %s at %L
target: ENTRY result %s cannot be of type %s in FUNCTION %s at %L

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

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

en: Enable SSA-BIT-CCP optimization on trees
target: Enable SSA-BIT-CCP 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 basic block vectorization (SLP) on trees
target: Enable basic block vectorisation (SLP) on trees

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 link-time optimization.
target: Enable link-time optimisation.

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 optimization of static class initialization code
target: Enable optimisation of static class initialisation code

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: 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 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: FUNCTION result %s can't be a POINTER in FUNCTION %s at %L
target: FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L

en: FUNCTION result %s can't be an array in FUNCTION %s at %L
target: FUNCTION result %s cannot be an array in FUNCTION %s at %L

en: FUNCTION result %s can't be of type %s in FUNCTION %s at %L
target: FUNCTION result %s cannot be of type %s in FUNCTION %s at %L

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: Fortran 2008: Implied SAVE for module variable '%s' at %L, needed due to the default initialization
target: Fortran 2008: Implied SAVE for module variable '%s' at %L, needed due to the default initialisation

en: Fortran 2008: non-NULL pointer initialization at %C
target: Fortran 2008: non-NULL pointer initialisation at %C

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 function
target: Function '%s' in initialisation expression at %L must be an intrinsic function

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

en: GENERIC '%s' at %L can't overwrite specific binding with the same name
target: GENERIC '%s' at %L cannot overwrite specific binding with the same name

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: 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)
target: Graphite loop optimisations cannot be used (-fgraphite, -fgraphite-identity, -floop-block, -floop-flatten, -floop-interchange, -floop-strip-mine, -floop-parallelize-all, and -ftree-loop-linear)

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++ does not allow initializers in lambda expression capture lists
target: ISO C++ does not allow initialisers in lambda expression capture lists

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 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-vectorise 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 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: Initialization string starting at %L was truncated to fit the variable (%d/%d)
target: Initialisation string starting at %L was truncated to fit the variable (%d/%d)

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 initialization expression for ALLOCATABLE component '%s' in structure constructor at %L
target: Invalid initialisation expression for ALLOCATABLE component '%s' in structure constructor at %L

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: Label '%s' at %C doesn't match IF label '%s'
target: Label '%s' at %C does not match IF label '%s'

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: Maximum length of partial antic set when performing tree pre optimization
target: Maximum length of partial antic set when performing tree pre optimisation

en: Maximum number of instructions in basic block to be considered for SLP vectorization
target: Maximum number of instructions in basic block to be considered for SLP vectorisation

en: Maximum size of a type list associated with each parameter for devirtualization
target: Maximum size of a type list associated with each parameter for devirtualisation

en: NON_OVERRIDABLE and DEFERRED can't both appear at %C
target: NON_OVERRIDABLE and DEFERRED cannot both appear 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: Optimize for space rather than speed
target: Optimise for space rather than speed

en: Optimize for speed disregarding exact standards compliance
target: Optimise for speed disregarding exact standards compliance

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: 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 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: Plugins
target: Plug-ins

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

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

en: Pointer initialization target at %C must have the TARGET attribute
target: Pointer initialisation target at %C must have the TARGET attribute

en: Pointer initialization target at %C must not be ALLOCATABLE
target: Pointer initialisation target at %C must not be ALLOCATABLE

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

en: Pointer initialization target at %L must not be ALLOCATABLE
target: Pointer initialisation target at %L must not be ALLOCATABLE

en: Probability that COMDAT function will be shared with different compilatoin unit
target: Probability that COMDAT function will be shared with different compilation unit

en: Procedure '%s' at %L with parametrized derived type argument '%s' must have an explicit interface
target: Procedure '%s' at %L with parameterised derived type argument '%s' must have an explicit interface

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: 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: Report various link-time optimization statistics
target: Report various link-time optimisation statistics

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: Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations
target: Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimisations

en: Specify a plugin to load
target: Specify a plug-in to load

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 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: Use table lookup optimization for small signed integer divisions
target: Use table lookup optimisation for small signed integer divisions

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: 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 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 non-trivial assumptions.

en: Warn when a jump misses a variable initialization
target: Warn when a jump misses a variable initialisation

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: a brace-enclosed initializer is not allowed here
target: a 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: argument %qD doesn%'t match built-in prototype
target: argument %qD does not match built-in prototype

en: argument %qD doesn%'t match prototype
target: argument %qD does not match prototype

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 bound forbidden after parenthesized type-id
target: array bound forbidden after parenthesised 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 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: asm operand %d probably doesn%'t match constraints
target: asm operand %d probably does not match constraints

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 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 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: 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%'t close input file %s: %m
target: cannot close input file %s: %m

en: can%'t convert between vector values of different size
target: cannot convert between vector values of different size

en: can%'t convert value to a vector
target: cannot convert value to a vector

en: can%'t create repository information file %qs
target: cannot create repository information file %qs

en: can%'t do dependency tracking with input from stdin
target: cannot do dependency tracking with input from stdin

en: can%'t find %<class$%> in %qT
target: cannot find %<class$%> in %qT

en: can%'t find a register in class %qs while reloading %<asm%>
target: cannot find a register in class %qs while reloading %<asm%>

en: can%'t get position in PCH file: %m
target: cannot get position in PCH file: %m

en: can%'t initialize friend function %qs
target: can%'t initialise friend function %qs

en: can%'t mix operands of decimal float and complex types
target: cannot mix operands of decimal float and complex types

en: can%'t mix operands of decimal float and other float types
target: cannot mix operands of decimal float and other float types

en: can%'t mix operands of decimal float and vector types
target: cannot mix operands of decimal float and vector types

en: can%'t open %s for reading: %m
target: cannot open %s for reading: %m

en: can%'t open %s for writing: %m
target: cannot open %s for writing: %m

en: can%'t open %s: %m
target: cannot open %s: %m

en: can%'t read PCH file: %m
target: cannot read PCH file: %m

en: can%'t seek PCH file: %m
target: cannot seek PCH file: %m

en: can%'t set %qE attribute after definition
target: cannot set %qE attribute after definition

en: can%'t specify %<-D%> without %<--main%>
target: cannot specify %<-D%> without %<--main%>

en: can%'t use %qs as a call-saved register
target: cannot use %qs as a call-saved register

en: can%'t use %qs as a call-used register
target: cannot use %qs as a call-used register

en: can%'t use %qs as a fixed register
target: cannot use %qs as a fixed register

en: can%'t write PCH file
target: cannot write PCH file

en: can%'t write PCH file: %m
target: cannot write PCH file: %m

en: can%'t write padding to PCH file: %m
target: cannot write padding to PCH file: %m

en: can't get program status
target: cannot get program status

en: can't open input file: %s
target: cannot open input file: %s

en: can't open ldd output
target: cannot open ldd output

en: can't open nm output
target: cannot open nm output

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 find %s in plugin %s
    %s
target: cannot find %s in plug-in %s
    %s

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: 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: 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: 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: extended initializer lists only available with -std=c++0x or -std=gnu++0x
target: extended initialiser lists only available with -std=c++0x or -std=gnu++0x

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: fail to initialize plugin %s
target: fail to initialise plug-in %s

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 declaration isn%'t a prototype
target: function declaration is not a prototype

en: function template partial specialization %qD is not allowed
target: function template partial specialisation %qD is not allowed

en: gimple bytecode streams do not support the optimization attribute
target: gimple bytecode streams do not support the optimisation attribute

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: inacessible plugin file %s expanded from short plugin name %s: %m
target: inaccessible plug-in file %s expanded from short plug-in name %s: %m

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 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: intrinsic variable which isn't a procedure
target: intrinsic variable which is not a procedure

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: maximum number of basic blocks per function to be analyzed by Graphite
target: maximum number of basic blocks per function to be analysed by Graphite

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: 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 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-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-delegitimized UNSPEC %d found in variable location
target: non-delegitimised UNSPEC %d found in variable location

en: non-static data member initializers
target: non-static data member initialisers

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: number of arguments doesn%'t match built-in prototype
target: number of arguments does not match built-in prototype

en: number of arguments doesn%'t match prototype
target: number of arguments does not match prototype

en: number of operands and imm-links don%'t agree in statement
target: number of operands and imm-links do not agree in statement

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: offset of empty base %qT may not be ABI-compliant and maychange in a future version of GCC
target: offset of empty base %qT may not be ABI-compliant and may change in a future version of GCC

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

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 options not supported yet
target: optimisation options not supported yet

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: partial specialization of %qT after instantiation of %qT
target: partial specialisation of %qT after instantiation of %qT

en: picochip_print_memory_address - Operand isn't memory based
target: picochip_print_memory_address - Operand is not memory based

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

en: plugin %s registered a null callback function for event %s
target: plug-in %s registered a null callback function for event %s

en: plugin %s should be specified before -fplugin-arg-%s in the command line
target: plug-in %s should be specified before -fplugin-arg-%s in the command line

en: plugin %s was specified with different paths:
    %s
    %s
target: plug-in %s was specified with different paths:
    %s
    %s

en: plugin cannot register a missing pass
target: plug-in cannot register a missing pass

en: plugin cannot register an unnamed pass
target: plug-in cannot register an unnamed pass

en: plugin cannot register pass %qs without reference pass name
target: plug-in cannot register pass %qs without reference pass name

en: plugin support is disabled; configure with --enable-plugin
target: plug-in support is disabled; configure with --enable-plugin

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

en: promoted argument %qD doesn%'t match built-in prototype
target: promoted argument %qD does not match built-in prototype

en: promoted argument %qD doesn%'t match prototype
target: promoted argument %qD does not match prototype

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: statement marked for throw, but doesn%'t
target: statement marked for throw, but does not

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

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 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: 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: the language is not recognized
target: the language is not recognised

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 base %qT in %<constexpr%> constructor
target: uninitialised base %qT in %<constexpr%> constructor

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

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 member %qD in %<constexpr%> constructor
target: uninitialised member %qD in %<constexpr%> constructor

en: uninitialized member %qD with %<const%> type %qT
target: uninitialised member %qD with %<const%> type %qT

en: uninitialized non-static const member %q#D
target: uninitialised non-static const member %q#D

en: uninitialized non-static reference member %q#D
target: uninitialised non-static reference member %q#D

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

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

en: unrecognizable insn:
target: unrecognisable insn:

en: unrecognized address
target: unrecognised address

en: unrecognized argument '%s' to -mcpu= option
target: unrecognised argument '%s' to -mcpu= option

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 argument to -mmcu= option: %qs
target: unrecognised argument to -mmcu= option: %qs

en: unrecognized command line option "%s"
target: unrecognised command line option "%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 option %<-%s%>
target: unrecognised option %<-%s%>

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: unreocgnized control register number: %d - using 'psw'
target: unrecognised control register number: %d - using 'psw'

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

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

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

en: variable %D of type %<cb%> must be uninitialized
target: variable %D of type %<cb%> must be uninitialised

en: variable %D of type %<io%> must be uninitialized
target: variable %D of type %<io%> must be uninitialised

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

en: variable %q#D with %<auto%> type used in its own initializer
target: variable %q#D with %<auto%> type used in its own initialiser

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: 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
